public void assert_success() { Result<String> test = Result.success("success"); assertThat(test) .isSuccess() .hasValue("success"); }
public void evaluate() { PositionTokenEvaluator evaluator = new PositionTokenEvaluator(); Position pos = trade(); EvaluationResult quantity = evaluator.evaluate(pos, FUNCTIONS, "quantity", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(6d); EvaluationResult initialPrice = evaluator.evaluate(pos, FUNCTIONS, "security", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(SECURITY); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(pos, FUNCTIONS, "Security", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(SECURITY); // Unknown property EvaluationResult foo = evaluator.evaluate(pos, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
public void evaluate() { SecurityTokenEvaluator evaluator = new SecurityTokenEvaluator(); Security sec = security(); EvaluationResult quantity = evaluator.evaluate(sec, FUNCTIONS, "id", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(ID); EvaluationResult initialPrice = evaluator.evaluate(sec, FUNCTIONS, "currency", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(USD); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(sec, FUNCTIONS, "Currency", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(USD); // Unknown property EvaluationResult foo = evaluator.evaluate(sec, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
public void assert_success_map() { Result<String> success = Result.success("success"); Result<Integer> test = success.map(MAP_STRLEN); assertThat(test).isSuccess().hasValue(7); }
public void assert_success_flatMap() { Result<String> success = Result.success("success"); Result<Integer> test = success.flatMap(FUNCTION_STRLEN); assertThat(test).isSuccess().hasValue(7); }
public void combine_iterableWithSuccesses() { 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.combine( results, s -> "res" + s.reduce(1, (i1, i2) -> i1 * i2)); assertThat(combined) .isSuccess() .hasValue("res24"); }
public void flatCombine_iterableWithSuccesses_combineSucceeds() { 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.success("res" + s.reduce(1, (i1, i2) -> i1 * i2))); assertThat(combined) .isSuccess() .hasValue("res24"); }
public void assert_success_combineWith_success() { Result<String> success1 = Result.success("Hello"); Result<String> success2 = Result.success("World"); Result<String> test = success1.combineWith(success2, FUNCTION_MERGE); assertThat(test).isSuccess().hasValue("Hello World"); }
public void evaluate() { TradeTokenEvaluator evaluator = new TradeTokenEvaluator(); Trade trade = trade(); EvaluationResult quantity = evaluator.evaluate(trade, FUNCTIONS, "quantity", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(123d); EvaluationResult initialPrice = evaluator.evaluate(trade, FUNCTIONS, "price", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(456d); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(trade, FUNCTIONS, "price", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(456d); EvaluationResult counterparty = evaluator.evaluate(trade, FUNCTIONS, "counterparty", ImmutableList.of()); assertThat(counterparty.getResult()).hasValue(StandardId.of("cpty", "a")); // Optional property with no value EvaluationResult tradeTime = evaluator.evaluate(trade, FUNCTIONS, "tradeTime", ImmutableList.of()); assertThat(tradeTime.getResult()).isFailure(); // Unknown property EvaluationResult foo = evaluator.evaluate(trade, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
/** * Tests evaluating a bean with a single property. There are 2 different expected behaviours: * * 1) If the token matches the property, the property value is returned and the token is consumed. This is the same * as the normal bean behaviour. * 2) If the token doesn't match the property it is assumed to match something on the property's value. In this * case the property value is returned and no tokens are consumed. */ public void evaluateSingleProperty() { SwapLegAmount amount = SwapLegAmount.builder() .amount(CurrencyAmount.of(Currency.AUD, 7)) .payReceive(PayReceive.PAY) .type(SwapLegType.FIXED) .currency(Currency.AUD) .build(); LegAmounts amounts = LegAmounts.of(amount); BeanTokenEvaluator evaluator = new BeanTokenEvaluator(); EvaluationResult result1 = evaluator.evaluate(amounts, FUNCTIONS, "amounts", ImmutableList.of("foo", "bar")); assertThat(result1.getResult()).hasValue(ImmutableList.of(amount)); assertThat(result1.getRemainingTokens()).isEqualTo(ImmutableList.of("foo", "bar")); EvaluationResult result2 = evaluator.evaluate(amounts, FUNCTIONS, "baz", ImmutableList.of("foo", "bar")); assertThat(result2.getResult()).hasValue(ImmutableList.of(amount)); assertThat(result2.getRemainingTokens()).isEqualTo(ImmutableList.of("baz", "foo", "bar")); }
assertThat(result3.getResult()).hasValue(sensitivity2);