public void failure_fromStatusMessageArgs_placeholdersLessThanArgs1() { Result<String> failure = Result.failure(ERROR, "my {} failure", "blue", "rabbit"); Result<Integer> test = Result.failure(failure); assertTrue(test.isFailure()); assertEquals(test.getFailure().getMessage(), "my blue failure - [rabbit]"); }
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() { 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)); }
/** * Returns the position from the row. * * @return the position from the row */ Result<Position> getPosition() { CalculationTarget target = getTarget(); if (target instanceof Position) { return Result.success((Position) target); } return Result.failure(FailureReason.INVALID, "Calculaton target is not a position"); }
return allSuccessful(results) ? success(function.apply(extractSuccesses(results))) : failure(results); return failure(e);
public void failure_fromResults_varargs1() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 1"); Result<Object> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<Object> failure2 = Result.failure(ERROR, "failure 2"); Result<Object> test = Result.failure(success1, success2, failure1, failure2); Set<FailureItem> expected = new HashSet<>(); expected.addAll(failure1.getFailure().getItems()); expected.addAll(failure2.getFailure().getItems()); assertEquals(test.getFailure().getItems(), expected); }
public void failureDifferentTypes() { Result<Object> failure1 = Result.failure(MISSING_DATA, "message 1"); Result<Object> failure2 = Result.failure(CALCULATION_FAILED, "message 2"); Result<Object> failure3 = Result.failure(ERROR, "message 3"); Result<?> composite = Result.failure(failure1, failure2, failure3); assertEquals(composite.getFailure().getReason(), FailureReason.MULTIPLE); assertEquals(composite.getFailure().getMessage(), "message 1, message 2, message 3"); }
/** * Returns the actual result value if calculated successfully, throwing an * exception if a failure occurred. * <p> * If this result is a failure then an {@code IllegalStateException} will be thrown. * To avoid this, call {@link #isSuccess()} or {@link #isFailure()} first. * <p> * Application code is recommended to use {@link #map(Function)} and * {@link #flatMap(Function)} in preference to this method. * * @return the result value, only available if calculated successfully * @throws IllegalStateException if called on a failure result */ public T getValue() { if (isFailure()) { throw new IllegalStateException("Unable to get a value from a failure result: " + getFailure().getMessage()); } return value; }
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")); }
@Override protected String formatData(TradeReport report, int rowIdx, int colIdx, ReportOutputFormat format) { TradeReportColumn templateColumn = report.getColumns().get(colIdx); Result<?> result = report.getData().get(rowIdx, colIdx); if (result.isFailure()) { return templateColumn.isIgnoreFailures() ? "" : Messages.format("FAIL: {}", result.getFailure().getMessage()); } Object value = result.getValue(); return formatValue(value, format); }
public void allSuccess_varargs() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 1"); Result<Object> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<Object> failure2 = Result.failure(ERROR, "failure 2"); assertFalse(Result.allSuccessful(failure1, failure2)); assertFalse(Result.allSuccessful(failure1, success1)); assertTrue(Result.allSuccessful(success1, success2)); }
public void anyFailures_varargs() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 1"); Result<Object> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<Object> failure2 = Result.failure(ERROR, "failure 2"); assertTrue(Result.anyFailures(failure1, failure2)); assertTrue(Result.anyFailures(failure1, success1)); assertFalse(Result.anyFailures(success1, success2)); }
public void flatCombine_iterableWithSuccesses_combineFails() { Result<Integer> success1 = Result.success(1); Result<Integer> success2 = Result.success(2); Result<Integer> success3 = Result.success(3); Result<Integer> success4 = Result.success(4); Set<Result<Integer>> results = ImmutableSet.of(success1, success2, success3, success4); Result<String> combined = Result.flatCombine( results, s -> Result.failure(CALCULATION_FAILED, "Could not do it")); assertThat(combined) .isFailure(CALCULATION_FAILED); }
public void countFailures_varargs() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 1"); Result<Object> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<Object> failure2 = Result.failure(ERROR, "failure 2"); assertEquals(Result.countFailures(failure1, failure2), 2); assertEquals(Result.countFailures(failure1, success1), 1); assertEquals(Result.countFailures(success1, success2), 0); }
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 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 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"); }