This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new 5d1a551 Fix checkstyle: End files in a new line.
5d1a551 is described below
commit 5d1a5517c99067a49b85891f194d09bf00ec1006
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Wed Jun 17 16:38:47 2020 -0400
Fix checkstyle: End files in a new line.
---
.../lang3/function/FailableBooleanSupplier.java | 2 +-
.../function/FailableDoubleBinaryOperator.java | 2 +-
.../lang3/function/FailableDoubleConsumer.java | 2 +-
.../lang3/function/FailableDoubleFunction.java | 2 +-
.../lang3/function/FailableDoublePredicate.java | 2 +-
.../lang3/function/FailableDoubleSupplier.java | 2 +-
.../function/FailableDoubleToIntFunction.java | 2 +-
.../function/FailableDoubleToLongFunction.java | 2 +-
.../lang3/function/FailableIntBinaryOperator.java | 2 +-
.../lang3/function/FailableIntConsumer.java | 2 +-
.../lang3/function/FailableIntFunction.java | 2 +-
.../lang3/function/FailableIntPredicate.java | 2 +-
.../lang3/function/FailableIntSupplier.java | 2 +-
.../function/FailableIntToDoubleFunction.java | 2 +-
.../lang3/function/FailableIntToLongFunction.java | 2 +-
.../lang3/function/FailableLongBinaryOperator.java | 2 +-
.../lang3/function/FailableLongConsumer.java | 2 +-
.../lang3/function/FailableLongFunction.java | 2 +-
.../lang3/function/FailableLongPredicate.java | 2 +-
.../lang3/function/FailableLongSupplier.java | 2 +-
.../function/FailableLongToDoubleFunction.java | 2 +-
.../lang3/function/FailableLongToIntFunction.java | 2 +-
.../lang3/function/FailableObjDoubleConsumer.java | 2 +-
.../lang3/function/FailableObjIntConsumer.java | 2 +-
.../lang3/function/FailableObjLongConsumer.java | 2 +-
.../lang3/function/FailableToDoubleBiFunction.java | 2 +-
.../lang3/function/FailableToDoubleFunction.java | 2 +-
.../lang3/function/FailableToIntBiFunction.java | 2 +-
.../lang3/function/FailableToIntFunction.java | 2 +-
.../lang3/function/FailableToLongBiFunction.java | 2 +-
.../lang3/function/FailableToLongFunction.java | 2 +-
.../lang3/function/FailableFunctionsTest.java | 611 +++++++++++++++------
32 files changed, 475 insertions(+), 198 deletions(-)
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
index 0deaef5..25870de 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
@@ -35,4 +35,4 @@ public interface FailableBooleanSupplier<T extends Throwable>
{
* @throws T if the supplier fails
*/
boolean getAsBoolean() throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
index db58976..1968044 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
@@ -37,4 +37,4 @@ public interface FailableDoubleBinaryOperator<T extends
Throwable> {
* @throws T if the operation fails
*/
double applyAsDouble(double left, double right) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
index ade6e0c..63bc40e 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
@@ -35,4 +35,4 @@ public interface FailableDoubleConsumer<T extends Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(double value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
index 156b204..48dec10 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
@@ -37,4 +37,4 @@ public interface FailableDoubleFunction<R, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
R apply(double input) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
index fda8786..e4bf163 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
@@ -36,4 +36,4 @@ public interface FailableDoublePredicate<T extends Throwable>
{
* @throws T Thrown when the consumer fails.
*/
boolean test(double value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
index 9fb751b..47ac129 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
@@ -35,4 +35,4 @@ public interface FailableDoubleSupplier<T extends Throwable> {
* @throws T if the supplier fails
*/
double getAsDouble() throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
index 00db9f3..403400f 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
@@ -36,4 +36,4 @@ public interface FailableDoubleToIntFunction<T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
int applyAsInt(double value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
index 0eae76c..71cab0e 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
@@ -36,4 +36,4 @@ public interface FailableDoubleToLongFunction<T extends
Throwable> {
* @throws T if the operation fails
*/
int applyAsLong(double value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
index 3eaca9d..7e41e54 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
@@ -37,4 +37,4 @@ public interface FailableIntBinaryOperator<T extends
Throwable> {
* @throws T if the operation fails
*/
int applyAsInt(int left, int right) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
index 54e7710..e7ce74c 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
@@ -35,4 +35,4 @@ public interface FailableIntConsumer<T extends Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(int value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
index 07e35c6..907f098 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
@@ -37,4 +37,4 @@ public interface FailableIntFunction<R, T extends Throwable> {
* @throws T Thrown when the function fails.
*/
R apply(int input) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
index 40e3877..3687f9c 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
@@ -36,4 +36,4 @@ public interface FailableIntPredicate<T extends Throwable> {
* @throws T Thrown when the consumer fails.
*/
boolean test(int value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
index fed9cd2..f1f72e4 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
@@ -35,4 +35,4 @@ public interface FailableIntSupplier<T extends Throwable> {
* @throws T if the supplier fails
*/
int getAsInt() throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
index f0d9164..51a81ac 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
@@ -36,4 +36,4 @@ public interface FailableIntToDoubleFunction<T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
double applyAsDouble(int value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
index f88d5ef..aef8c57 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
@@ -36,4 +36,4 @@ public interface FailableIntToLongFunction<T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
long applyAsLong(int value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
index e58acf4..6ddf2ab 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
@@ -37,4 +37,4 @@ public interface FailableLongBinaryOperator<T extends
Throwable> {
* @throws T if the operation fails
*/
long applyAsLong(long left, long right) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
index 7eb784f..465112e 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
@@ -35,4 +35,4 @@ public interface FailableLongConsumer<T extends Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(long object) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
index 904f946..b36b272 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
@@ -37,4 +37,4 @@ public interface FailableLongFunction<R, T extends Throwable>
{
* @throws T Thrown when the function fails.
*/
R apply(long input) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
index 259b82e..3255082 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
@@ -36,4 +36,4 @@ public interface FailableLongPredicate<T extends Throwable> {
* @throws T Thrown when the consumer fails.
*/
boolean test(long value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
index 67a1aa4..31d42a2 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
@@ -35,4 +35,4 @@ public interface FailableLongSupplier<T extends Throwable> {
* @throws T if the supplier fails
*/
long getAsLong() throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
index dcd64ec..f83d6a2 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
@@ -36,4 +36,4 @@ public interface FailableLongToDoubleFunction<T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
double applyAsDouble(long value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
index 80cb6ae..825491e 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
@@ -36,4 +36,4 @@ public interface FailableLongToIntFunction<T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
int applyAsInt(long value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
index a18d3f3..70555d5 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
@@ -37,4 +37,4 @@ public interface FailableObjDoubleConsumer<O, T extends
Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(O object, double value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
index 21bf5cd..68954a4 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
@@ -37,4 +37,4 @@ public interface FailableObjIntConsumer<O, T extends
Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(O object, int value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
index 32c4256..a503f5e 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
@@ -37,4 +37,4 @@ public interface FailableObjLongConsumer<O, T extends
Throwable> {
* @throws T Thrown when the consumer fails.
*/
void accept(O object, long value) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
index de932f4..766383b 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
@@ -39,4 +39,4 @@ public interface FailableToDoubleBiFunction<O1, O2, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
double applyAsDouble(O1 t, O2 u) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
index 1edc934..9e3fedd 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
@@ -37,4 +37,4 @@ public interface FailableToDoubleFunction<I, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
double applyAsDouble(I t) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
index 126a80c..7430a09 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
@@ -39,4 +39,4 @@ public interface FailableToIntBiFunction<O1, O2, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
int applyAsInt(O1 t, O2 u) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
index 27c2dae..0fc91ad 100644
--- a/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
+++ b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
@@ -37,4 +37,4 @@ public interface FailableToIntFunction<I, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
int applyAsInt(I t) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
index dcf2fca..6a34026 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
@@ -39,4 +39,4 @@ public interface FailableToLongBiFunction<O1, O2, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
long applyAsLong(O1 t, O2 u) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
index 9995411..f46bbcc 100644
---
a/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
+++
b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
@@ -37,4 +37,4 @@ public interface FailableToLongFunction<I, T extends
Throwable> {
* @throws T Thrown when the function fails.
*/
long applyAsLong(I t) throws T;
-}
\ No newline at end of file
+}
diff --git
a/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
index c0ce3af..468c5a4 100644
--- a/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
+++ b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
@@ -27,8 +27,17 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.lang.reflect.UndeclaredThrowableException;
+import java.util.concurrent.Callable;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
import org.apache.commons.lang3.Functions;
+import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
@@ -66,17 +75,17 @@ public class FailableFunctionsTest {
return true;
}
- static boolean testDouble(double value) throws SomeException {
+ static boolean testDouble(final double value) throws SomeException {
throwOnOdd();
return true;
}
- static boolean testInt(int value) throws SomeException {
+ static boolean testInt(final int value) throws SomeException {
throwOnOdd();
return true;
}
- static boolean testLong(long value) throws SomeException {
+ static boolean testLong(final long value) throws SomeException {
throwOnOdd();
return true;
}
@@ -149,7 +158,7 @@ public class FailableFunctionsTest {
test(throwable);
}
- public Object test(Object input1, Object input2) throws Throwable {
+ public Object test(final Object input1, final Object input2) throws
Throwable {
test(throwable);
return acceptedObject;
}
@@ -215,41 +224,41 @@ public class FailableFunctionsTest {
return 0;
}
- public void testDouble(double i) throws Throwable {
+ public void testDouble(final double i) throws Throwable {
test(throwable);
acceptedPrimitiveObject1 = (P) ((Double) i);
}
- public double testDoubleDouble(double i, double j) throws Throwable {
+ public double testDoubleDouble(final double i, final double j) throws
Throwable {
test(throwable);
acceptedPrimitiveObject1 = (P) ((Double) i);
acceptedPrimitiveObject2 = (P) ((Double) j);
return 3d;
}
- public void testInt(int i) throws Throwable {
+ public void testInt(final int i) throws Throwable {
test(throwable);
acceptedPrimitiveObject1 = (P) ((Integer) i);
}
- public void testLong(long i) throws Throwable {
+ public void testLong(final long i) throws Throwable {
test(throwable);
acceptedPrimitiveObject1 = (P) ((Long) i);
}
- public void testObjDouble(T object, double i) throws Throwable {
+ public void testObjDouble(final T object, final double i) throws
Throwable {
test(throwable);
acceptedObject = object;
acceptedPrimitiveObject1 = (P) ((Double) i);
}
- public void testObjInt(T object, int i) throws Throwable {
+ public void testObjInt(final T object, final int i) throws Throwable {
test(throwable);
acceptedObject = object;
acceptedPrimitiveObject1 = (P) ((Integer) i);
}
- public void testObjLong(T object, long i) throws Throwable {
+ public void testObjLong(final T object, final long i) throws Throwable
{
test(throwable);
acceptedObject = object;
acceptedPrimitiveObject1 = (P) ((Long) i);
@@ -257,106 +266,151 @@ public class FailableFunctionsTest {
}
@Test
- public void testAcceptDoubleConsumer() {
+ void testAcceptBiConsumer() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(null);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(Testable::test, testable, ise));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(Testable::test, testable, error));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(Testable::test, testable, ioe));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ testable.setThrowable(null);
+ Failable.accept(Testable::test, testable, (Throwable) null);
+ }
+
+ @Test
+ void testAcceptConsumer() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(ise);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(Testable::test, testable));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ testable.setThrowable(error);
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(Testable::test, testable));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(Testable::test, testable));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ testable.setThrowable(null);
+ Failable.accept(Testable::test, testable);
+ }
+
+ @Test
+ void testAcceptDoubleConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, Double> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.accept(testable::testDouble, 1d));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(testable::testDouble, 1d));
assertSame(ise, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testDouble, 1d));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testDouble, 1d));
assertSame(error, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testDouble, 1d));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testDouble, 1d));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testDouble, 1d);
+ Failable.accept(testable::testDouble, 1d);
assertEquals(1, testable.getAcceptedPrimitiveObject1());
}
@Test
- public void testAcceptIntConsumer() {
+ void testAcceptIntConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, Integer> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.accept(testable::testInt, 1));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(testable::testInt, 1));
assertSame(ise, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testInt, 1));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testInt, 1));
assertSame(error, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testInt, 1));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testInt, 1));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testInt, 1);
+ Failable.accept(testable::testInt, 1);
assertEquals(1, testable.getAcceptedPrimitiveObject1());
}
@Test
- public void testAcceptLongConsumer() {
+ void testAcceptLongConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, Long> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.accept(testable::testLong, 1L));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(testable::testLong, 1L));
assertSame(ise, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testLong, 1L));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testLong, 1L));
assertSame(error, e);
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testLong, 1L));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testLong, 1L));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testLong, 1L);
+ Failable.accept(testable::testLong, 1L);
assertEquals(1, testable.getAcceptedPrimitiveObject1());
}
@Test
- public void testAcceptObjDoubleConsumer() {
+ void testAcceptObjDoubleConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<String, Double> testable = new Testable<>(ise);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.accept(testable::testObjDouble, "X", 1d));
+ () -> Failable.accept(testable::testObjDouble, "X", 1d));
assertSame(ise, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testObjDouble, "X", 1d));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testObjDouble, "X", 1d));
assertSame(error, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testObjDouble, "X", 1d));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testObjDouble, "X", 1d));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
@@ -364,30 +418,30 @@ public class FailableFunctionsTest {
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testObjDouble, "X", 1d);
+ Failable.accept(testable::testObjDouble, "X", 1d);
assertEquals("X", testable.getAcceptedObject());
assertEquals(1d, testable.getAcceptedPrimitiveObject1());
}
@Test
- public void testAcceptObjIntConsumer() {
+ void testAcceptObjIntConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<String, Integer> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.accept(testable::testObjInt, "X", 1));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(testable::testObjInt, "X", 1));
assertSame(ise, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testObjInt, "X", 1));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testObjInt, "X", 1));
assertSame(error, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testObjInt, "X", 1));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testObjInt, "X", 1));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
@@ -395,30 +449,30 @@ public class FailableFunctionsTest {
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testObjInt, "X", 1);
+ Failable.accept(testable::testObjInt, "X", 1);
assertEquals("X", testable.getAcceptedObject());
assertEquals(1, testable.getAcceptedPrimitiveObject1());
}
@Test
- public void testAcceptObjLongConsumer() {
+ void testAcceptObjLongConsumer() {
final IllegalStateException ise = new IllegalStateException();
final Testable<String, Long> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.accept(testable::testObjLong, "X", 1L));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.accept(testable::testObjLong, "X", 1L));
assertSame(ise, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.accept(testable::testObjLong, "X", 1L));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.accept(testable::testObjLong, "X", 1L));
assertSame(error, e);
assertNull(testable.getAcceptedObject());
assertNull(testable.getAcceptedPrimitiveObject1());
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.accept(testable::testObjLong, "X", 1L));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.accept(testable::testObjLong, "X", 1L));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
@@ -426,7 +480,7 @@ public class FailableFunctionsTest {
assertNull(testable.getAcceptedPrimitiveObject1());
testable.setThrowable(null);
- Functions.accept(testable::testObjLong, "X", 1L);
+ Failable.accept(testable::testObjLong, "X", 1L);
assertEquals("X", testable.getAcceptedObject());
assertEquals(1L, testable.getAcceptedPrimitiveObject1());
}
@@ -436,20 +490,20 @@ public class FailableFunctionsTest {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(null);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.apply(Testable::testAsInteger, testable, ise));
+ () -> Failable.apply(Testable::testAsInteger, testable, ise));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.apply(Testable::testAsInteger, testable, error));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.apply(Testable::testAsInteger, testable, error));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
- e = assertThrows(UncheckedIOException.class, () ->
Functions.apply(Testable::testAsInteger, testable, ioe));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.apply(Testable::testAsInteger, testable, ioe));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
- final Integer i = Functions.apply(Testable::testAsInteger, testable,
(Throwable) null);
+ final Integer i = Failable.apply(Testable::testAsInteger, testable,
(Throwable) null);
assertNotNull(i);
assertEquals(0, i.intValue());
}
@@ -458,12 +512,12 @@ public class FailableFunctionsTest {
public void testApplyDoubleBinaryOperator() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, Double> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.applyAsDouble(testable::testDoubleDouble, 1d, 2d));
+ final Throwable e = assertThrows(IllegalStateException.class,
+ () -> Failable.applyAsDouble(testable::testDoubleDouble, 1d, 2d));
assertSame(ise, e);
final Testable<?, Double> testable2 = new Testable<>(null);
- final double i = Functions.applyAsDouble(testable2::testDoubleDouble,
1d, 2d);
+ final double i = Failable.applyAsDouble(testable2::testDoubleDouble,
1d, 2d);
assertEquals(3d, i);
}
@@ -472,31 +526,74 @@ public class FailableFunctionsTest {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.apply(Testable::testAsInteger, testable));
+ () -> Failable.apply(Testable::testAsInteger, testable));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.apply(Testable::testAsInteger, testable));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.apply(Testable::testAsInteger, testable));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.apply(Testable::testAsInteger, testable));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.apply(Testable::testAsInteger, testable));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- final Integer i = Functions.apply(Testable::testAsInteger, testable);
+ final Integer i = Failable.apply(Testable::testAsInteger, testable);
assertNotNull(i);
assertEquals(0, i.intValue());
}
@Test
- public void testAsRunnable() {
+ void testAsCallable() {
+ FailureOnOddInvocations.invocations = 0;
+ final FailableCallable<FailureOnOddInvocations, SomeException>
failableCallable = FailureOnOddInvocations::new;
+ final Callable<FailureOnOddInvocations> callable =
Failable.asCallable(failableCallable);
+ final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class, callable::call);
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof SomeException);
+ assertEquals("Odd Invocation: 1", cause.getMessage());
+ final FailureOnOddInvocations instance;
+ try {
+ instance = callable.call();
+ } catch (final Exception ex) {
+ throw Failable.rethrow(ex);
+ }
+ assertNotNull(instance);
+ }
+
+ @Test
+ void testAsConsumer() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(ise);
+ final Consumer<Testable<?, ?>> consumer =
Failable.asConsumer(Testable::test);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
consumer.accept(testable));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ testable.setThrowable(error);
+ e = assertThrows(OutOfMemoryError.class, () ->
consumer.accept(testable));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
consumer.accept(testable));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ testable.setThrowable(null);
+ Failable.accept(Testable::test, testable);
+ }
+
+ @Test
+ void testAsRunnable() {
FailureOnOddInvocations.invocations = 0;
- final Runnable runnable =
Functions.asRunnable(FailureOnOddInvocations::new);
+ final Runnable runnable =
Failable.asRunnable(FailureOnOddInvocations::new);
final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class, runnable::run);
final Throwable cause = e.getCause();
assertNotNull(cause);
@@ -508,6 +605,109 @@ public class FailableFunctionsTest {
}
@Test
+ public void testAsSupplier() {
+ FailureOnOddInvocations.invocations = 0;
+ final FailableSupplier<FailureOnOddInvocations, Throwable>
failableSupplier = FailureOnOddInvocations::new;
+ final Supplier<FailureOnOddInvocations> supplier =
Failable.asSupplier(failableSupplier);
+ final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class, supplier::get);
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof SomeException);
+ assertEquals("Odd Invocation: 1", cause.getMessage());
+ assertNotNull(supplier.get());
+ }
+
+ @Test
+ void testBiConsumer() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(null);
+ final FailableBiConsumer<Testable<?, ?>, Throwable, Throwable>
failableBiConsumer = (t, th) -> {
+ t.setThrowable(th);
+ t.test();
+ };
+ final BiConsumer<Testable<?, ?>, Throwable> consumer =
Failable.asBiConsumer(failableBiConsumer);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
consumer.accept(testable, ise));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ e = assertThrows(OutOfMemoryError.class, () ->
consumer.accept(testable, error));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
consumer.accept(testable, ioe));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ consumer.accept(testable, null);
+ }
+
+ @Test
+ public void testBiFunction() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(ise);
+ final FailableBiFunction<Testable<?, ?>, Throwable, Integer,
Throwable> failableBiFunction = (t, th) -> {
+ t.setThrowable(th);
+ return Integer.valueOf(t.testAsInteger());
+ };
+ final BiFunction<Testable<?, ?>, Throwable, Integer> biFunction =
Failable.asBiFunction(failableBiFunction);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
biFunction.apply(testable, ise));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ testable.setThrowable(error);
+ e = assertThrows(OutOfMemoryError.class, () ->
biFunction.apply(testable, error));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
biFunction.apply(testable, ioe));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ assertEquals(0, biFunction.apply(testable, null).intValue());
+ }
+
+ @Test
+ @DisplayName("Test that asPredicate(FailableBiPredicate) is converted to
-> BiPredicate ")
+ public void testBiPredicate() {
+ FailureOnOddInvocations.invocations = 0;
+ final FailableBiPredicate<Object, Object, Throwable>
failableBiPredicate = (t1,
+ t2) -> FailureOnOddInvocations.failingBool();
+ final BiPredicate<?, ?> predicate =
Failable.asBiPredicate(failableBiPredicate);
+ final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class,
+ () -> predicate.test(null, null));
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof SomeException);
+ assertEquals("Odd Invocation: 1", cause.getMessage());
+ final boolean instance = predicate.test(null, null);
+ assertNotNull(instance);
+ }
+
+ @Test
+ void testCallable() {
+ FailureOnOddInvocations.invocations = 0;
+ final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class,
+ () -> Failable.run(FailureOnOddInvocations::new));
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof SomeException);
+ assertEquals("Odd Invocation: 1", cause.getMessage());
+ final FailureOnOddInvocations instance =
Failable.call(FailureOnOddInvocations::new);
+ assertNotNull(instance);
+ }
+
+ @Test
+ public void testConstructor() {
+ // We allow this, which must have been an omission to make the ctor
private.
+ // We could make the ctor private in 4.0.
+ new Functions();
+ }
+
+ @Test
public void testDoublePredicate() throws Throwable {
FailureOnOddInvocations.invocations = 0;
final FailableDoublePredicate<Throwable> failablePredicate = t1 ->
FailureOnOddInvocations.testDouble(t1);
@@ -516,27 +716,54 @@ public class FailableFunctionsTest {
}
@Test
+ public void testFunction() {
+ final IllegalStateException ise = new IllegalStateException();
+ final Testable<?, ?> testable = new Testable<>(ise);
+ final FailableFunction<Throwable, Integer, Throwable> failableFunction
= th -> {
+ testable.setThrowable(th);
+ return Integer.valueOf(testable.testAsInteger());
+ };
+ final Function<Throwable, Integer> function =
Failable.asFunction(failableFunction);
+ Throwable e = assertThrows(IllegalStateException.class, () ->
function.apply(ise));
+ assertSame(ise, e);
+
+ final Error error = new OutOfMemoryError();
+ testable.setThrowable(error);
+ e = assertThrows(OutOfMemoryError.class, () -> function.apply(error));
+ assertSame(error, e);
+
+ final IOException ioe = new IOException("Unknown I/O error");
+ testable.setThrowable(ioe);
+ e = assertThrows(UncheckedIOException.class, () ->
function.apply(ioe));
+ final Throwable t = e.getCause();
+ assertNotNull(t);
+ assertSame(ioe, t);
+
+ assertEquals(0, function.apply(null).intValue());
+ }
+
+ @Test
public void testGetAsBooleanSupplier() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.getAsBoolean(testable::testAsBooleanPrimitive));
+ () -> Failable.getAsBoolean(testable::testAsBooleanPrimitive));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.getAsBoolean(testable::testAsBooleanPrimitive));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.getAsBoolean(testable::testAsBooleanPrimitive));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.getAsBoolean(testable::testAsBooleanPrimitive));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.getAsBoolean(testable::testAsBooleanPrimitive));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- assertFalse(Functions.getAsBoolean(testable::testAsBooleanPrimitive));
+ assertFalse(Failable.getAsBoolean(testable::testAsBooleanPrimitive));
}
@Test
@@ -544,46 +771,46 @@ public class FailableFunctionsTest {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.getAsDouble(testable::testAsDoublePrimitive));
+ () -> Failable.getAsDouble(testable::testAsDoublePrimitive));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.getAsDouble(testable::testAsDoublePrimitive));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.getAsDouble(testable::testAsDoublePrimitive));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.getAsDouble(testable::testAsDoublePrimitive));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.getAsDouble(testable::testAsDoublePrimitive));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- assertEquals(0,
Functions.getAsDouble(testable::testAsDoublePrimitive));
+ assertEquals(0, Failable.getAsDouble(testable::testAsDoublePrimitive));
}
@Test
public void testGetAsIntSupplier() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.getAsInt(testable::testAsIntPrimitive));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.getAsInt(testable::testAsIntPrimitive));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.getAsInt(testable::testAsIntPrimitive));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.getAsInt(testable::testAsIntPrimitive));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.getAsInt(testable::testAsIntPrimitive));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.getAsInt(testable::testAsIntPrimitive));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- final int i = Functions.getAsInt(testable::testAsInteger);
+ final int i = Failable.getAsInt(testable::testAsInteger);
assertEquals(0, i);
}
@@ -592,23 +819,23 @@ public class FailableFunctionsTest {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
Throwable e = assertThrows(IllegalStateException.class,
- () -> Functions.getAsLong(testable::testAsLongPrimitive));
+ () -> Failable.getAsLong(testable::testAsLongPrimitive));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.getAsLong(testable::testAsLongPrimitive));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.getAsLong(testable::testAsLongPrimitive));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.getAsLong(testable::testAsLongPrimitive));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.getAsLong(testable::testAsLongPrimitive));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- final long i = Functions.getAsLong(testable::testAsLongPrimitive);
+ final long i = Failable.getAsLong(testable::testAsLongPrimitive);
assertEquals(0, i);
}
@@ -616,12 +843,12 @@ public class FailableFunctionsTest {
public void testGetFromSupplier() {
FailureOnOddInvocations.invocations = 0;
final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class,
- () -> Functions.run(FailureOnOddInvocations::new));
+ () -> Failable.run(FailureOnOddInvocations::new));
final Throwable cause = e.getCause();
assertNotNull(cause);
assertTrue(cause instanceof SomeException);
assertEquals("Odd Invocation: 1", cause.getMessage());
- final FailureOnOddInvocations instance =
Functions.call(FailureOnOddInvocations::new);
+ final FailureOnOddInvocations instance =
Failable.call(FailureOnOddInvocations::new);
assertNotNull(instance);
}
@@ -629,23 +856,23 @@ public class FailableFunctionsTest {
public void testGetSupplier() {
final IllegalStateException ise = new IllegalStateException();
final Testable<?, ?> testable = new Testable<>(ise);
- Throwable e = assertThrows(IllegalStateException.class, () ->
Functions.get(testable::testAsInteger));
+ Throwable e = assertThrows(IllegalStateException.class, () ->
Failable.get(testable::testAsInteger));
assertSame(ise, e);
final Error error = new OutOfMemoryError();
testable.setThrowable(error);
- e = assertThrows(OutOfMemoryError.class, () ->
Functions.get(testable::testAsInteger));
+ e = assertThrows(OutOfMemoryError.class, () ->
Failable.get(testable::testAsInteger));
assertSame(error, e);
final IOException ioe = new IOException("Unknown I/O error");
testable.setThrowable(ioe);
- e = assertThrows(UncheckedIOException.class, () ->
Functions.get(testable::testAsInteger));
+ e = assertThrows(UncheckedIOException.class, () ->
Failable.get(testable::testAsInteger));
final Throwable t = e.getCause();
assertNotNull(t);
assertSame(ioe, t);
testable.setThrowable(null);
- final Integer i = Functions.apply(Testable::testAsInteger, testable);
+ final Integer i = Failable.apply(Testable::testAsInteger, testable);
assertNotNull(i);
assertEquals(0, i.intValue());
}
@@ -667,17 +894,34 @@ public class FailableFunctionsTest {
}
@Test
- public void testRunnable() {
+ @DisplayName("Test that asPredicate(FailablePredicate) is converted to ->
Predicate ")
+ public void testPredicate() {
+ FailureOnOddInvocations.invocations = 0;
+ final FailablePredicate<Object, Throwable> failablePredicate = t ->
FailureOnOddInvocations
+ .failingBool();
+ final Predicate<?> predicate = Failable.asPredicate(failablePredicate);
+ final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class,
+ () -> predicate.test(null));
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof SomeException);
+ assertEquals("Odd Invocation: 1", cause.getMessage());
+ final boolean instance = predicate.test(null);
+ assertNotNull(instance);
+ }
+
+ @Test
+ void testRunnable() {
FailureOnOddInvocations.invocations = 0;
final UndeclaredThrowableException e =
assertThrows(UndeclaredThrowableException.class,
- () -> Functions.run(FailureOnOddInvocations::new));
+ () -> Failable.run(FailureOnOddInvocations::new));
final Throwable cause = e.getCause();
assertNotNull(cause);
assertTrue(cause instanceof SomeException);
assertEquals("Odd Invocation: 1", cause.getMessage());
// Even invocations, should not throw an exception
- Functions.run(FailureOnOddInvocations::new);
+ Failable.run(FailureOnOddInvocations::new);
}
/**
@@ -685,11 +929,11 @@ public class FailableFunctionsTest {
* Object and Throwable.
*/
@Test
- public void testThrows_FailableBiConsumer_Object_Throwable() {
- new Functions.FailableBiConsumer<Object, Object, Throwable>() {
+ void testThrows_FailableBiConsumer_Object_Throwable() {
+ new FailableBiConsumer<Object, Object, Throwable>() {
@Override
- public void accept(Object object1, Object object2) throws
Throwable {
+ public void accept(final Object object1, final Object object2)
throws Throwable {
throw new IOException("test");
}
};
@@ -700,11 +944,11 @@ public class FailableFunctionsTest {
* generic test types.
*/
@Test
- public void testThrows_FailableBiConsumer_String_IOException() {
- new Functions.FailableBiConsumer<String, String, IOException>() {
+ void testThrows_FailableBiConsumer_String_IOException() {
+ new FailableBiConsumer<String, String, IOException>() {
@Override
- public void accept(String object1, String object2) throws
IOException {
+ public void accept(final String object1, final String object2)
throws IOException {
throw new IOException("test");
}
@@ -716,11 +960,11 @@ public class FailableFunctionsTest {
* Object and Throwable.
*/
@Test
- public void testThrows_FailableBiFunction_Object_Throwable() {
- new Functions.FailableBiFunction<Object, Object, Object, Throwable>() {
+ void testThrows_FailableBiFunction_Object_Throwable() {
+ new FailableBiFunction<Object, Object, Object, Throwable>() {
@Override
- public Object apply(Object input1, Object input2) throws Throwable
{
+ public Object apply(final Object input1, final Object input2)
throws Throwable {
throw new IOException("test");
}
};
@@ -731,11 +975,11 @@ public class FailableFunctionsTest {
* generic test types.
*/
@Test
- public void testThrows_FailableBiFunction_String_IOException() {
- new Functions.FailableBiFunction<String, String, String,
IOException>() {
+ void testThrows_FailableBiFunction_String_IOException() {
+ new FailableBiFunction<String, String, String, IOException>() {
@Override
- public String apply(String input1, String input2) throws
IOException {
+ public String apply(final String input1, final String input2)
throws IOException {
throw new IOException("test");
}
};
@@ -746,11 +990,11 @@ public class FailableFunctionsTest {
* Object and Throwable.
*/
@Test
- public void testThrows_FailableBiPredicate_Object_Throwable() {
- new Functions.FailableBiPredicate<Object, Object, Throwable>() {
+ void testThrows_FailableBiPredicate_Object_Throwable() {
+ new FailableBiPredicate<Object, Object, Throwable>() {
@Override
- public boolean test(Object object1, Object object2) throws
Throwable {
+ public boolean test(final Object object1, final Object object2)
throws Throwable {
throw new IOException("test");
}
};
@@ -761,11 +1005,11 @@ public class FailableFunctionsTest {
* generic test types.
*/
@Test
- public void testThrows_FailableBiPredicate_String_IOException() {
- new Functions.FailableBiPredicate<String, String, IOException>() {
+ void testThrows_FailableBiPredicate_String_IOException() {
+ new FailableBiPredicate<String, String, IOException>() {
@Override
- public boolean test(String object1, String object2) throws
IOException {
+ public boolean test(final String object1, final String object2)
throws IOException {
throw new IOException("test");
}
};
@@ -801,13 +1045,16 @@ public class FailableFunctionsTest {
};
}
+ ///////////////////////////////////////////////
+
+
/**
* Tests that our failable interface is properly defined to throw any
exception. using the top level generic types
* Object and Throwable.
*/
@Test
- public void testThrows_FailableCallable_Object_Throwable() {
- new Functions.FailableCallable<Object, Throwable>() {
+ void testThrows_FailableCallable_Object_Throwable() {
+ new FailableCallable<Object, Throwable>() {
@Override
public Object call() throws Throwable {
@@ -821,8 +1068,8 @@ public class FailableFunctionsTest {
* generic test types.
*/
@Test
- public void testThrows_FailableCallable_String_IOException() {
- new Functions.FailableCallable<String, IOException>() {
+ void testThrows_FailableCallable_String_IOException() {
+ new FailableCallable<String, IOException>() {
@Override
public String call() throws IOException {
@@ -836,11 +1083,11 @@ public class FailableFunctionsTest {
* Object and Throwable.
*/
@Test
- public void testThrows_FailableConsumer_Object_Throwable() {
- new Functions.FailableConsumer<Object, Throwable>() {
+ void testThrows_FailableConsumer_Object_Throwable() {
+ new FailableConsumer<Object, Throwable>() {
@Override
- public void accept(Object object) throws Throwable {
+ public void accept(final Object object) throws Throwable {
throw new IOException("test");
}
@@ -852,11 +1099,11 @@ public class FailableFunctionsTest {
* generic test types.
*/
@Test
- public void testThrows_FailableConsumer_String_IOException() {
- new Functions.FailableConsumer<String, IOException>() {
+ void testThrows_FailableConsumer_String_IOException() {
+ new FailableConsumer<String, IOException>() {
@Override
- public void accept(String object) throws IOException {
+ public void accept(final String object) throws IOException {
throw new IOException("test");
}
@@ -872,7 +1119,7 @@ public class FailableFunctionsTest {
new FailableDoubleBinaryOperator<Throwable>() {
@Override
- public double applyAsDouble(double left, double right) throws
Throwable {
+ public double applyAsDouble(final double left, final double right)
throws Throwable {
throw new IOException("test");
}
};
@@ -887,7 +1134,7 @@ public class FailableFunctionsTest {
new FailableDoubleBinaryOperator<IOException>() {
@Override
- public double applyAsDouble(double left, double right) throws
IOException {
+ public double applyAsDouble(final double left, final double right)
throws IOException {
throw new IOException("test");
}
};
@@ -902,7 +1149,7 @@ public class FailableFunctionsTest {
new FailableDoubleConsumer<Throwable>() {
@Override
- public void accept(double value) throws Throwable {
+ public void accept(final double value) throws Throwable {
throw new IOException("test");
}
@@ -918,7 +1165,7 @@ public class FailableFunctionsTest {
new FailableDoubleConsumer<IOException>() {
@Override
- public void accept(double value) throws IOException {
+ public void accept(final double value) throws IOException {
throw new IOException("test");
}
};
@@ -933,7 +1180,7 @@ public class FailableFunctionsTest {
new FailableDoubleFunction<Object, Throwable>() {
@Override
- public Object apply(double input) throws Throwable {
+ public Object apply(final double input) throws Throwable {
throw new IOException("test");
}
};
@@ -948,7 +1195,7 @@ public class FailableFunctionsTest {
new FailableDoubleFunction<String, IOException>() {
@Override
- public String apply(double input) throws IOException {
+ public String apply(final double input) throws IOException {
throw new IOException("test");
}
};
@@ -993,7 +1240,7 @@ public class FailableFunctionsTest {
new FailableDoubleToIntFunction<Throwable>() {
@Override
- public int applyAsInt(double value) throws Throwable {
+ public int applyAsInt(final double value) throws Throwable {
throw new IOException("test");
}
};
@@ -1008,7 +1255,7 @@ public class FailableFunctionsTest {
new FailableDoubleToIntFunction<IOException>() {
@Override
- public int applyAsInt(double value) throws IOException {
+ public int applyAsInt(final double value) throws IOException {
throw new IOException("test");
}
};
@@ -1023,7 +1270,7 @@ public class FailableFunctionsTest {
new FailableDoubleToLongFunction<Throwable>() {
@Override
- public int applyAsLong(double value) throws Throwable {
+ public int applyAsLong(final double value) throws Throwable {
throw new IOException("test");
}
};
@@ -1038,7 +1285,7 @@ public class FailableFunctionsTest {
new FailableDoubleToLongFunction<IOException>() {
@Override
- public int applyAsLong(double value) throws IOException {
+ public int applyAsLong(final double value) throws IOException {
throw new IOException("test");
}
};
@@ -1050,10 +1297,10 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableFunction_Object_Throwable() {
- new Functions.FailableFunction<Object, Object, Throwable>() {
+ new FailableFunction<Object, Object, Throwable>() {
@Override
- public Object apply(Object input) throws Throwable {
+ public Object apply(final Object input) throws Throwable {
throw new IOException("test");
}
};
@@ -1065,10 +1312,10 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableFunction_String_IOException() {
- new Functions.FailableFunction<String, String, IOException>() {
+ new FailableFunction<String, String, IOException>() {
@Override
- public String apply(String input) throws IOException {
+ public String apply(final String input) throws IOException {
throw new IOException("test");
}
};
@@ -1083,7 +1330,7 @@ public class FailableFunctionsTest {
new FailableIntBinaryOperator<Throwable>() {
@Override
- public int applyAsInt(int left, int right) throws Throwable {
+ public int applyAsInt(final int left, final int right) throws
Throwable {
throw new IOException("test");
}
};
@@ -1098,7 +1345,7 @@ public class FailableFunctionsTest {
new FailableIntBinaryOperator<IOException>() {
@Override
- public int applyAsInt(int left, int right) throws IOException {
+ public int applyAsInt(final int left, final int right) throws
IOException {
throw new IOException("test");
}
};
@@ -1113,7 +1360,7 @@ public class FailableFunctionsTest {
new FailableIntConsumer<Throwable>() {
@Override
- public void accept(int value) throws Throwable {
+ public void accept(final int value) throws Throwable {
throw new IOException("test");
}
@@ -1129,7 +1376,7 @@ public class FailableFunctionsTest {
new FailableIntConsumer<IOException>() {
@Override
- public void accept(int value) throws IOException {
+ public void accept(final int value) throws IOException {
throw new IOException("test");
}
};
@@ -1144,7 +1391,7 @@ public class FailableFunctionsTest {
new FailableIntFunction<Object, Throwable>() {
@Override
- public Object apply(int input) throws Throwable {
+ public Object apply(final int input) throws Throwable {
throw new IOException("test");
}
};
@@ -1159,7 +1406,7 @@ public class FailableFunctionsTest {
new FailableIntFunction<String, IOException>() {
@Override
- public String apply(int input) throws IOException {
+ public String apply(final int input) throws IOException {
throw new IOException("test");
}
};
@@ -1204,7 +1451,7 @@ public class FailableFunctionsTest {
new FailableIntToDoubleFunction<Throwable>() {
@Override
- public double applyAsDouble(int value) throws Throwable {
+ public double applyAsDouble(final int value) throws Throwable {
throw new IOException("test");
}
};
@@ -1219,7 +1466,7 @@ public class FailableFunctionsTest {
new FailableIntToDoubleFunction<IOException>() {
@Override
- public double applyAsDouble(int value) throws IOException {
+ public double applyAsDouble(final int value) throws IOException {
throw new IOException("test");
}
};
@@ -1234,7 +1481,7 @@ public class FailableFunctionsTest {
new FailableIntToLongFunction<Throwable>() {
@Override
- public long applyAsLong(int value) throws Throwable {
+ public long applyAsLong(final int value) throws Throwable {
throw new IOException("test");
}
};
@@ -1249,7 +1496,7 @@ public class FailableFunctionsTest {
new FailableIntToLongFunction<IOException>() {
@Override
- public long applyAsLong(int value) throws IOException {
+ public long applyAsLong(final int value) throws IOException {
throw new IOException("test");
}
};
@@ -1264,7 +1511,7 @@ public class FailableFunctionsTest {
new FailableLongBinaryOperator<Throwable>() {
@Override
- public long applyAsLong(long left, long right) throws Throwable {
+ public long applyAsLong(final long left, final long right) throws
Throwable {
throw new IOException("test");
}
};
@@ -1279,7 +1526,7 @@ public class FailableFunctionsTest {
new FailableLongBinaryOperator<IOException>() {
@Override
- public long applyAsLong(long left, long right) throws IOException {
+ public long applyAsLong(final long left, final long right) throws
IOException {
throw new IOException("test");
}
};
@@ -1294,7 +1541,7 @@ public class FailableFunctionsTest {
new FailableLongConsumer<Throwable>() {
@Override
- public void accept(long object) throws Throwable {
+ public void accept(final long object) throws Throwable {
throw new IOException("test");
}
@@ -1310,7 +1557,7 @@ public class FailableFunctionsTest {
new FailableLongConsumer<IOException>() {
@Override
- public void accept(long object) throws IOException {
+ public void accept(final long object) throws IOException {
throw new IOException("test");
}
@@ -1326,7 +1573,7 @@ public class FailableFunctionsTest {
new FailableLongFunction<Object, Throwable>() {
@Override
- public Object apply(long input) throws Throwable {
+ public Object apply(final long input) throws Throwable {
throw new IOException("test");
}
};
@@ -1341,7 +1588,7 @@ public class FailableFunctionsTest {
new FailableLongFunction<String, IOException>() {
@Override
- public String apply(long input) throws IOException {
+ public String apply(final long input) throws IOException {
throw new IOException("test");
}
};
@@ -1386,7 +1633,7 @@ public class FailableFunctionsTest {
new FailableLongToDoubleFunction<Throwable>() {
@Override
- public double applyAsDouble(long value) throws Throwable {
+ public double applyAsDouble(final long value) throws Throwable {
throw new IOException("test");
}
};
@@ -1401,7 +1648,7 @@ public class FailableFunctionsTest {
new FailableLongToDoubleFunction<IOException>() {
@Override
- public double applyAsDouble(long value) throws IOException {
+ public double applyAsDouble(final long value) throws IOException {
throw new IOException("test");
}
};
@@ -1416,7 +1663,7 @@ public class FailableFunctionsTest {
new FailableLongToIntFunction<Throwable>() {
@Override
- public int applyAsInt(long value) throws Throwable {
+ public int applyAsInt(final long value) throws Throwable {
throw new IOException("test");
}
};
@@ -1431,7 +1678,7 @@ public class FailableFunctionsTest {
new FailableLongToIntFunction<IOException>() {
@Override
- public int applyAsInt(long value) throws IOException {
+ public int applyAsInt(final long value) throws IOException {
throw new IOException("test");
}
};
@@ -1446,7 +1693,7 @@ public class FailableFunctionsTest {
new FailableObjDoubleConsumer<Object, Throwable>() {
@Override
- public void accept(Object object, double value) throws Throwable {
+ public void accept(final Object object, final double value) throws
Throwable {
throw new IOException("test");
}
@@ -1462,7 +1709,7 @@ public class FailableFunctionsTest {
new FailableObjDoubleConsumer<String, IOException>() {
@Override
- public void accept(String object, double value) throws IOException
{
+ public void accept(final String object, final double value) throws
IOException {
throw new IOException("test");
}
};
@@ -1477,7 +1724,7 @@ public class FailableFunctionsTest {
new FailableObjIntConsumer<Object, Throwable>() {
@Override
- public void accept(Object object, int value) throws Throwable {
+ public void accept(final Object object, final int value) throws
Throwable {
throw new IOException("test");
}
@@ -1493,7 +1740,7 @@ public class FailableFunctionsTest {
new FailableObjIntConsumer<String, IOException>() {
@Override
- public void accept(String object, int value) throws IOException {
+ public void accept(final String object, final int value) throws
IOException {
throw new IOException("test");
}
};
@@ -1508,7 +1755,7 @@ public class FailableFunctionsTest {
new FailableObjLongConsumer<Object, Throwable>() {
@Override
- public void accept(Object object, long value) throws Throwable {
+ public void accept(final Object object, final long value) throws
Throwable {
throw new IOException("test");
}
@@ -1524,7 +1771,7 @@ public class FailableFunctionsTest {
new FailableObjLongConsumer<String, IOException>() {
@Override
- public void accept(String object, long value) throws IOException {
+ public void accept(final String object, final long value) throws
IOException {
throw new IOException("test");
}
};
@@ -1536,10 +1783,10 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailablePredicate_Object_Throwable() {
- new Functions.FailablePredicate<Object, Throwable>() {
+ new FailablePredicate<Object, Throwable>() {
@Override
- public boolean test(Object object) throws Throwable {
+ public boolean test(final Object object) throws Throwable {
throw new IOException("test");
}
};
@@ -1551,10 +1798,10 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailablePredicate_String_IOException() {
- new Functions.FailablePredicate<String, IOException>() {
+ new FailablePredicate<String, IOException>() {
@Override
- public boolean test(String object) throws IOException {
+ public boolean test(final String object) throws IOException {
throw new IOException("test");
}
};
@@ -1566,7 +1813,7 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableRunnable_Object_Throwable() {
- new Functions.FailableRunnable<Throwable>() {
+ new FailableRunnable<Throwable>() {
@Override
public void run() throws Throwable {
@@ -1582,7 +1829,7 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableRunnable_String_IOException() {
- new Functions.FailableRunnable<IOException>() {
+ new FailableRunnable<IOException>() {
@Override
public void run() throws IOException {
@@ -1597,7 +1844,7 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableSupplier_Object_Throwable() {
- new Functions.FailableSupplier<Object, Throwable>() {
+ new FailableSupplier<Object, Throwable>() {
@Override
public Object get() throws Throwable {
@@ -1612,7 +1859,7 @@ public class FailableFunctionsTest {
*/
@Test
public void testThrows_FailableSupplier_String_IOException() {
- new Functions.FailableSupplier<String, IOException>() {
+ new FailableSupplier<String, IOException>() {
@Override
public String get() throws IOException {
@@ -1630,7 +1877,7 @@ public class FailableFunctionsTest {
new FailableToDoubleBiFunction<Object, Object, Throwable>() {
@Override
- public double applyAsDouble(Object t, Object u) throws Throwable {
+ public double applyAsDouble(final Object t, final Object u) throws
Throwable {
throw new IOException("test");
}
};
@@ -1645,7 +1892,7 @@ public class FailableFunctionsTest {
new FailableToDoubleBiFunction<String, String, IOException>() {
@Override
- public double applyAsDouble(String t, String u) throws IOException
{
+ public double applyAsDouble(final String t, final String u) throws
IOException {
throw new IOException("test");
}
};
@@ -1660,7 +1907,7 @@ public class FailableFunctionsTest {
new FailableToDoubleFunction<Object, Throwable>() {
@Override
- public double applyAsDouble(Object t) throws Throwable {
+ public double applyAsDouble(final Object t) throws Throwable {
throw new IOException("test");
}
};
@@ -1675,7 +1922,7 @@ public class FailableFunctionsTest {
new FailableToDoubleFunction<String, IOException>() {
@Override
- public double applyAsDouble(String t) throws IOException {
+ public double applyAsDouble(final String t) throws IOException {
throw new IOException("test");
}
};
@@ -1690,7 +1937,7 @@ public class FailableFunctionsTest {
new FailableToIntBiFunction<Object, Object, Throwable>() {
@Override
- public int applyAsInt(Object t, Object u) throws Throwable {
+ public int applyAsInt(final Object t, final Object u) throws
Throwable {
throw new IOException("test");
}
};
@@ -1705,7 +1952,7 @@ public class FailableFunctionsTest {
new FailableToIntBiFunction<String, String, IOException>() {
@Override
- public int applyAsInt(String t, String u) throws IOException {
+ public int applyAsInt(final String t, final String u) throws
IOException {
throw new IOException("test");
}
};
@@ -1720,7 +1967,7 @@ public class FailableFunctionsTest {
new FailableToIntFunction<Object, Throwable>() {
@Override
- public int applyAsInt(Object t) throws Throwable {
+ public int applyAsInt(final Object t) throws Throwable {
throw new IOException("test");
}
};
@@ -1735,7 +1982,7 @@ public class FailableFunctionsTest {
new FailableToIntFunction<String, IOException>() {
@Override
- public int applyAsInt(String t) throws IOException {
+ public int applyAsInt(final String t) throws IOException {
throw new IOException("test");
}
};
@@ -1750,7 +1997,7 @@ public class FailableFunctionsTest {
new FailableToLongBiFunction<Object, Object, Throwable>() {
@Override
- public long applyAsLong(Object t, Object u) throws Throwable {
+ public long applyAsLong(final Object t, final Object u) throws
Throwable {
throw new IOException("test");
}
};
@@ -1765,7 +2012,7 @@ public class FailableFunctionsTest {
new FailableToLongBiFunction<String, String, IOException>() {
@Override
- public long applyAsLong(String t, String u) throws IOException {
+ public long applyAsLong(final String t, final String u) throws
IOException {
throw new IOException("test");
}
};
@@ -1780,7 +2027,7 @@ public class FailableFunctionsTest {
new FailableToLongFunction<Object, Throwable>() {
@Override
- public long applyAsLong(Object t) throws Throwable {
+ public long applyAsLong(final Object t) throws Throwable {
throw new IOException("test");
}
};
@@ -1795,10 +2042,40 @@ public class FailableFunctionsTest {
new FailableToLongFunction<String, IOException>() {
@Override
- public long applyAsLong(String t) throws IOException {
+ public long applyAsLong(final String t) throws IOException {
throw new IOException("test");
}
};
}
+ @Test
+ public void testTryWithResources() {
+ final CloseableObject co = new CloseableObject();
+ final FailableConsumer<Throwable, ? extends Throwable> consumer =
co::run;
+ final IllegalStateException ise = new IllegalStateException();
+ Throwable e = assertThrows(IllegalStateException.class,
+ () -> Failable.tryWithResources(() -> consumer.accept(ise),
co::close));
+ assertSame(ise, e);
+
+ assertTrue(co.isClosed());
+ co.reset();
+ final Error error = new OutOfMemoryError();
+ e = assertThrows(OutOfMemoryError.class,
+ () -> Failable.tryWithResources(() -> consumer.accept(error),
co::close));
+ assertSame(error, e);
+
+ assertTrue(co.isClosed());
+ co.reset();
+ final IOException ioe = new IOException("Unknown I/O error");
+ final UncheckedIOException uioe =
assertThrows(UncheckedIOException.class,
+ () -> Failable.tryWithResources(() -> consumer.accept(ioe),
co::close));
+ final IOException cause = uioe.getCause();
+ assertSame(ioe, cause);
+
+ assertTrue(co.isClosed());
+ co.reset();
+ Failable.tryWithResources(() -> consumer.accept(null), co::close);
+ assertTrue(co.isClosed());
+ }
+
}
