/** * Converts this result to a stream. * <p> * If this result is a success then a single element stream containing the result value is returned. * If this result is a failure then an empty stream is returned. * * @return a stream of size one or zero */ public Stream<T> stream() { return (isSuccess() ? Stream.of(value) : Stream.empty()); }
/** * Returns the failure instance indicating the reason why the calculation failed. * <p> * If this result is a success then an an IllegalStateException will be thrown. * To avoid this, call {@link #isSuccess()} or {@link #isFailure()} first. * * @return the details of the failure, only available if calculation failed * @throws IllegalStateException if called on a success result */ public Failure getFailure() { if (isSuccess()) { throw new IllegalStateException("Unable to get a failure from a success result"); } return failure; }
/** * Returns a failed result from another failed result. * <p> * This method ensures the result type matches the expected type. * If the specified result is a successful result then an exception is thrown. * * @param <R> the expected result type * @param failureResult a failure result * @return a failure result of the expected type * @throws IllegalArgumentException if the result is a success */ @SuppressWarnings("unchecked") public static <R> Result<R> failure(Result<?> failureResult) { if (failureResult.isSuccess()) { throw new IllegalArgumentException("Result must be a failure"); } return (Result<R>) failureResult; }
/** * Returns the actual result value if calculated successfully, or the specified * default value if a failure occurred. * <p> * If this result is a success then the result value is returned. * If this result is a failure then the default value is returned. * The default value must not be null. * <p> * Application code is recommended to use {@link #map(Function)} and * {@link #flatMap(Function)} in preference to this method. * * @param defaultValue the default value to return if the result is a failure * @return either the result value or the default value */ public T getValueOrElse(T defaultValue) { ArgChecker.notNull(defaultValue, "defaultValue"); return (isSuccess() ? value : defaultValue); }
public void of_with_success() { Result<String> test = Result.of(() -> "success"); assertEquals(test.isSuccess(), true); assertEquals(test.isFailure(), false); assertEquals(test.getValue(), "success"); }
public void success_flatMap() { Result<String> success = Result.success("success"); Result<Integer> test = success.flatMap(FUNCTION_STRLEN); assertEquals(test.isSuccess(), true); assertEquals(test.getValue(), Integer.valueOf(7)); }
public void wrap_with_exception() { Result<String> test = Result.wrap(() -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertEquals(test.isFailure(), true); assertThrows(test::getValue, IllegalStateException.class); }
public void success_map() { Result<String> success = Result.success("success"); Result<Integer> test = success.map(MAP_STRLEN); assertEquals(test.isSuccess(), true); assertEquals(test.getValue(), Integer.valueOf(7)); }
public void of_with_exception() { Result<String> test = Result.of(() -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertEquals(test.isFailure(), true); assertThrows(test::getValue, IllegalStateException.class); }
public void wrap_with_success() { Result<String> test = Result.wrap(() -> Result.success("success")); assertEquals(test.isSuccess(), true); assertEquals(test.isFailure(), false); assertEquals(test.getValue(), "success"); }
public void success_combineWith_success() { Result<String> success1 = Result.success("Hello"); Result<String> success2 = Result.success("World"); Result<String> test = success1.combineWith(success2, FUNCTION_MERGE); assertEquals(test.isSuccess(), true); assertEquals(test.getValue(), "Hello World"); }
public void failure_flatMap_throwing() { Result<String> success = Result.failure(new IllegalArgumentException("failure")); Result<Integer> test = success.flatMap(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getMessage(), "failure"); }
public void failure_map_throwing() { Result<String> success = Result.failure(new IllegalArgumentException("failure")); Result<Integer> test = success.map(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getMessage(), "failure"); }
public void wrap_with_failure() { Result<String> test = Result.wrap(() -> Result.failure(ERROR, "Something failed")); assertEquals(test.isSuccess(), false); assertEquals(test.isFailure(), true); assertThrows(test::getValue, IllegalStateException.class); }
public void success_combineWith_failure() { Result<String> success = Result.success("Hello"); Result<String> failure = Result.failure(new IllegalArgumentException()); Result<String> test = success.combineWith(failure, FUNCTION_MERGE); assertEquals(test.isSuccess(), false); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getItems().size(), 1); }
public void success_map_throwing() { Result<String> success = Result.success("success"); Result<Integer> test = success.map(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertThat(test) .isFailure(ERROR) .hasFailureMessageMatching("Big bad error"); }
public void success_flatMap_throwing() { Result<String> success = Result.success("success"); Result<Integer> test = success.flatMap(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertThat(test) .isFailure(ERROR) .hasFailureMessageMatching("Big bad error"); }
public void success() { Result<String> test = Result.success("success"); assertEquals(test.isSuccess(), true); assertEquals(test.isFailure(), false); assertEquals(test.getValue(), "success"); assertEquals(test.getValueOrElse("blue"), "success"); assertThrowsIllegalArg(() -> test.getValueOrElse(null)); assertThrowsIllegalArg(() -> test.getValueOrElseApply(null)); }
public void failure() { IllegalArgumentException ex = new IllegalArgumentException("failure"); Result<String> test = Result.failure(ex); assertEquals(test.isSuccess(), false); assertEquals(test.isFailure(), true); assertEquals(test.getValueOrElse("blue"), "blue"); assertEquals(test.getValueOrElseApply(f -> "blue"), "blue"); assertEquals(test.getValueOrElseApply(Failure::getMessage), "failure"); assertThrowsIllegalArg(() -> test.getValueOrElse(null)); assertThrowsIllegalArg(() -> test.getValueOrElseApply(null)); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getMessage(), "failure"); assertEquals(test.getFailure().getItems().size(), 1); FailureItem item = test.getFailure().getItems().iterator().next(); assertEquals(item.getReason(), ERROR); assertEquals(item.getMessage(), "failure"); assertEquals(item.getCauseType().get(), ex.getClass()); assertEquals(item.getStackTrace(), Throwables.getStackTraceAsString(ex).replace(System.lineSeparator(), "\n")); }
/** * Assert that the {@code Result} is a Success. * * @return this, if the wrapped object is a success * @throws AssertionError if the wrapped object is a failure */ public ResultAssert isSuccess() { isNotNull(); if (!actual.isSuccess()) { Failure failure = actual.getFailure(); failWithMessage("Expected Success but was Failure with reason: <%s> and message: <%s>", failure.getReason(), failure.getMessage()); } return this; }