private static Result<?> noEvaluatorResult(List<String> remaining, Object value) { return Result.failure( FailureReason.INVALID, "Expression '{}' cannot be invoked on type {}", Joiner.on('.').join(remaining), value.getClass().getName()); }
/** * Creates a result for an unsuccessful evaluation of an expression. * * @param message the error message * @param messageValues values substituted into the error message. See {@link Messages#format(String, Object...)} * for details * @return the result of an unsuccessful evaluation of an expression */ public static EvaluationResult failure(String message, Object... messageValues) { String msg = Messages.format(message, messageValues); return new EvaluationResult(Result.failure(FailureReason.INVALID, msg), ImmutableList.of()); }
@Test(expectedExceptions = IllegalStateException.class) public void failure_getValue() { Result<String> test = Result.failure(new IllegalArgumentException()); test.getValue(); }
public void failureSameType() { Result<Object> failure1 = Result.failure(MISSING_DATA, "message 1"); Result<Object> failure2 = Result.failure(MISSING_DATA, "message 2"); Result<Object> failure3 = Result.failure(MISSING_DATA, "message 3"); Result<?> composite = Result.failure(failure1, failure2, failure3); assertEquals(composite.getFailure().getReason(), MISSING_DATA); assertEquals(composite.getFailure().getMessage(), "message 1, message 2, message 3"); }
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 failure_fromStatusMessageArgs_placeholdersMatchArgs2() { 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 rabbit failure"); }
public void countFailures_collection() { 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(ImmutableList.of(failure1, failure2)), 2); assertEquals(Result.countFailures(ImmutableList.of(failure1, success1)), 1); assertEquals(Result.countFailures(ImmutableList.of(success1, success2)), 0); }
public void allSuccess_collection() { 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(ImmutableList.of(failure1, failure2))); assertFalse(Result.allSuccessful(ImmutableList.of(failure1, success1))); assertTrue(Result.allSuccessful(ImmutableList.of(success1, success2))); }
public void getColumnTypesWithAllFailures() { ImmutableList<Integer> indices = ImmutableList.of(0, 1); ArrayTable<Integer, Integer, Result<?>> table = ArrayTable.create(indices, indices); table.put(0, 0, Result.failure(FailureReason.ERROR, "fail")); table.put(0, 1, Result.failure(FailureReason.ERROR, "fail")); table.put(1, 0, Result.failure(FailureReason.ERROR, "fail")); table.put(1, 1, Result.failure(FailureReason.ERROR, "fail")); List<Class<?>> columnTypes = TradeReportFormatter.INSTANCE.getColumnTypes(report(table)); assertThat(columnTypes).isEqualTo(ImmutableList.of(Object.class, Object.class)); }
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 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"); }
public void combine_iterableWithFailures() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 2"); Result<String> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<String> failure2 = Result.failure(ERROR, "failure 2"); Set<Result<String>> results = ImmutableSet.of(success1, success2, failure1, failure2); assertThat(Result.combine(results, s -> s)) .isFailure(FailureReason.MULTIPLE); }
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"); }
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 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_flatMap_ifSuccess() { Result<String> test = Result.failure(new IllegalArgumentException("failure")); Result<Integer> test1 = test.map(MAP_STRLEN); assertSame(test1, test); Result<Integer> test2 = test.flatMap(FUNCTION_STRLEN); assertSame(test2, test); }
public void getColumnTypesWithSomeFailures() { ImmutableList<Integer> indices = ImmutableList.of(0, 1); ArrayTable<Integer, Integer, Result<?>> table = ArrayTable.create(indices, indices); table.put(0, 0, Result.failure(FailureReason.ERROR, "fail")); table.put(0, 1, Result.failure(FailureReason.ERROR, "fail")); table.put(1, 0, Result.success(2)); table.put(1, 1, Result.success("def")); List<Class<?>> columnTypes = TradeReportFormatter.INSTANCE.getColumnTypes(report(table)); assertThat(columnTypes).isEqualTo(ImmutableList.of(Integer.class, String.class)); }
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 coverage() { Result<Object> failure = Result.failure(MISSING_DATA, "message 1"); TestHelper.coverImmutableBean(failure); TestHelper.coverImmutableBean(failure.getFailure()); TestHelper.coverImmutableBean(failure.getFailure().getItems().iterator().next()); Result<String> success = Result.success("Hello"); TestHelper.coverImmutableBean(success); TestHelper.coverEnum(FailureReason.class); }