@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case -934964668: // reason return ((Failure) bean).getReason(); case 954925063: // message return ((Failure) bean).getMessage(); case 100526016: // items return ((Failure) bean).getItems(); } return super.propertyGet(bean, propertyName, quiet); }
/** * Obtains a failure for multiple failure items. * * @param item the first failure item * @param additionalItems additional failure items * @return the failure */ public static Failure of(FailureItem item, FailureItem... additionalItems) { return of(ImmutableSet.<FailureItem>builder().add(item).add(additionalItems).build()); }
@Override public Failure build() { return new Failure( reason, message, items); }
/** * Creates a failed result combining multiple failed results. * <p> * The input results can be successes or failures, only the failures will be included in the created result. * Intended to be used with {@link #anyFailures(Iterable)}. * <blockquote><pre> * if (Result.anyFailures(results) { * return Result.failure(results); * } * </pre></blockquote> * * @param <R> the expected type of the result * @param results multiple results, of which at least one must be a failure, not empty * @return a failed result wrapping multiple other failed results * @throws IllegalArgumentException if results is empty or contains nothing but successes */ public static <R> Result<R> failure(Iterable<? extends Result<?>> results) { ArgChecker.notEmpty(results, "results"); ImmutableSet<FailureItem> items = Guavate.stream(results) .filter(Result::isFailure) .map(Result::getFailure) .flatMap(f -> f.getItems().stream()) .collect(Guavate.toImmutableSet()); if (items.isEmpty()) { throw new IllegalArgumentException("All results were successes"); } return new Result<>(Failure.of(items)); }
public void generateFailureFromException() { Exception exception = new Exception("something went wrong"); Result<Object> test = Result.failure(exception); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getMessage(), "something went wrong"); }
/** * Returns an exception wrapping a failure that couldn't be handled. * * @param failure a failure that couldn't be handled */ public FailureException(Failure failure) { super(failure.getMessage()); this.failure = ArgChecker.notNull(failure, "failure"); }
public void generatedStackTrace_Failure() { Failure test = Failure.of(FailureReason.INVALID, "my {} {} failure", "big", "bad"); assertEquals(test.getReason(), FailureReason.INVALID); assertEquals(test.getMessage(), "my big bad failure"); assertEquals(test.getItems().size(), 1); FailureItem item = test.getItems().iterator().next(); assertFalse(item.getCauseType().isPresent()); assertFalse(item.getStackTrace().contains(".FailureItem.of(")); assertFalse(item.getStackTrace().contains(".Failure.of(")); assertTrue(item.getStackTrace().startsWith("com.opengamma.strata.collect.result.FailureItem: my big bad failure")); assertTrue(item.getStackTrace().contains(".generatedStackTrace_Failure(")); assertEquals(item.toString(), "INVALID: my big bad failure"); }
public void failure_fromFailure() { Failure failure = Failure.of(ERROR, "my failure"); Result<Integer> test = Result.failure(failure); assertTrue(test.isFailure()); assertEquals(test.getFailure().getMessage(), "my failure"); assertEquals(test.getFailure().getItems().size(), 1); FailureItem item = test.getFailure().getItems().iterator().next(); assertEquals(item.getReason(), ERROR); assertEquals(item.getMessage(), "my failure"); assertEquals(item.getCauseType().isPresent(), false); assertTrue(item.getStackTrace() != null); }
public void failureDeduplicateFailure() { Result<Object> result = Result.failure(MISSING_DATA, "failure"); FailureItem failure = result.getFailure().getItems().iterator().next(); Result<Object> test = Result.failure(result, result); assertEquals(test.getFailure().getItems().size(), 1); assertEquals(test.getFailure().getItems(), ImmutableSet.of(failure)); assertEquals(test.getFailure().getMessage(), "failure"); }
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 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); }
/** * Assert that the {@code Result} is a failure with the specified reason. * * @param expected the expected failure reason * @return this, if the wrapped object is a failure with the specified reason * @throws AssertionError if the wrapped object is a success, or does not have the expected reason */ public ResultAssert isFailure(FailureReason expected) { isFailure(); FailureReason actualReason = actual.getFailure().getReason(); if (actualReason != expected) { failWithMessage("Expected Failure with reason: <%s> but was Failure with reason: <%s>", expected, actualReason); } return this; }
public void generateFailureFromExceptionWithMessage() { Exception exception = new Exception("something went wrong"); Result<Object> test = Result.failure(exception, "my message"); assertEquals(test.getFailure().getReason(), ERROR); assertEquals(test.getFailure().getMessage(), "my message"); }
/** * 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 ofNullable_null() { Result<Integer> test = Result.ofNullable(null); assertTrue(test.isFailure()); assertEquals(test.getFailure().getMessage(), "Found null where a value was expected"); assertEquals(test.getFailure().getItems().size(), 1); FailureItem item = test.getFailure().getItems().iterator().next(); assertEquals(item.getReason(), MISSING_DATA); assertEquals(item.getMessage(), "Found null where a value was expected"); assertEquals(item.getCauseType().isPresent(), false); assertTrue(item.getStackTrace() != null); }
public void failure_fromResults_varargs2() { 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, failure1, success2, failure2); Set<FailureItem> expected = new HashSet<>(); expected.addAll(failure1.getFailure().getItems()); expected.addAll(failure2.getFailure().getItems()); assertEquals(test.getFailure().getItems(), expected); }
public void generateFailureFromExceptionWithCustomStatus() { Exception exception = new Exception("something went wrong"); Result<Object> test = Result.failure(CALCULATION_FAILED, exception); assertEquals(test.getFailure().getReason(), CALCULATION_FAILED); assertEquals(test.getFailure().getMessage(), "something went wrong"); }
public void generatedStackTrace() { Result<Object> test = Result.failure(FailureReason.INVALID, "my {} {} failure", "big", "bad"); assertEquals(test.getFailure().getReason(), FailureReason.INVALID); assertEquals(test.getFailure().getMessage(), "my big bad failure"); assertEquals(test.getFailure().getItems().size(), 1); FailureItem item = test.getFailure().getItems().iterator().next(); assertFalse(item.getCauseType().isPresent()); assertFalse(item.getStackTrace().contains(".FailureItem.of(")); assertFalse(item.getStackTrace().contains(".Failure.of(")); assertTrue(item.getStackTrace().startsWith("com.opengamma.strata.collect.result.FailureItem: my big bad failure")); assertTrue(item.getStackTrace().contains(".generatedStackTrace(")); assertEquals(item.toString(), "INVALID: my big bad failure"); }
public void measurePath_failure_unknownMeasure() { ReportCalculationResults reportResults = reportResults(); List<Result<?>> results = ValuePathEvaluator.evaluate("Measures.Wibble", reportResults); Result<?> result = results.get(0); assertThat(result.isFailure()).isTrue(); assertThat(result.getFailure().getMessage()).contains("Wibble"); assertThat(result.getFailure().getMessage()).contains("PresentValue"); assertThat(result.getFailure().getMessage()).contains("ParRate"); }
public void failure_fromResult_failure() { Result<String> failure = Result.failure(ERROR, "my failure"); Result<Integer> test = Result.failure(failure); assertTrue(test.isFailure()); assertEquals(test.getFailure().getMessage(), "my failure"); assertEquals(test.getFailure().getItems().size(), 1); FailureItem item = test.getFailure().getItems().iterator().next(); assertEquals(item.getReason(), ERROR); assertEquals(item.getMessage(), "my failure"); assertEquals(item.getCauseType().isPresent(), false); assertEquals(item.getStackTrace().contains(".FailureItem.of("), false); assertEquals(item.getStackTrace().contains(".Failure.of("), false); assertEquals(item.getStackTrace().contains(".Result.failure("), false); }