src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ExpressionBuilder implements TypedExpression<T> { @Override public String label(Scope scope) { return lhs.label(scope); } protected ExpressionBuilder(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); @Override String toString(); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); N isEqualTo(T value); N isEqualTo(TypedExpression<T> expression); N isEqualTo(Function1<R,T> getter); N isEqualTo(FunctionOptional1<R,T> getter); N isEqualTo(String alias, Function1<R,T> getter); N isEqualTo(String alias, FunctionOptional1<R,T> getter); N isEqualTo(Alias<R> alias, Function1<R,T> getter); N isEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isNotEqualTo(T value); N isNotEqualTo(TypedExpression<T> expression); N isNotEqualTo(Function1<R,T> getter); N isNotEqualTo(FunctionOptional1<R,T> getter); N isNotEqualTo(String alias, Function1<R,T> getter); N isNotEqualTo(String alias, FunctionOptional1<R,T> getter); N isNotEqualTo(Alias<R> alias, Function1<R,T> getter); N isNotEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThan(T value); N isGreaterThan(TypedExpression<T> expression); N isGreaterThan(Function1<R,T> getter); N isGreaterThan(FunctionOptional1<R,T> getter); N isGreaterThan(String alias, Function1<R,T> getter); N isGreaterThan(String alias, FunctionOptional1<R,T> getter); N isGreaterThan(Alias<R> alias, Function1<R,T> getter); N isGreaterThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThan(T value); N isLessThan(TypedExpression<T> expression); N isLessThan(Function1<R,T> getter); N isLessThan(FunctionOptional1<R,T> getter); N isLessThan(String alias, Function1<R,T> getter); N isLessThan(String alias, FunctionOptional1<R,T> getter); N isLessThan(Alias<R> alias, Function1<R,T> getter); N isLessThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(T value); N isGreaterThanOrEqualTo(TypedExpression<T> expression); N isGreaterThanOrEqualTo(Function1<R,T> getter); N isGreaterThanOrEqualTo(FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(String alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(T value); N isLessThanOrEqualTo(TypedExpression<T> expression); N isLessThanOrEqualTo(Function1<R,T> getter); N isLessThanOrEqualTo(FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(String alias, Function1<R,T> getter); N isLessThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); @SafeVarargs final N isIn(T... values); @SafeVarargs final N isIn(TypedExpression<T>... values); @SafeVarargs final N isNotIn(T... values); @SafeVarargs final N isNotIn(TypedExpression<T>... values); N isIn(Select<T> select); N isNotIn(Select<T> select); N isNull(); N isNotNull(); N isLike(T value); N isLike(T value, String escape); N isLike(TypedExpression<T> value); N isLike(TypedExpression<T> value, String escape); N isNotLike(T value); N isNotLike(T value, String escape); N isNotLike(TypedExpression<T> value); N isNotLike(TypedExpression<T> value, String escape); BetweenBuilder<T,N> isBetween(T value); BetweenBuilder<T,N> isBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isBetween(Function1<R,T> getter); BetweenBuilder<T,N> isBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(T value); BetweenBuilder<T,N> isNotBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isNotBetween(Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, FunctionOptional1<R,T> getter); ExpressionBuilder<String,N> concat(U arg); ExpressionBuilder<String,N> concat(TypedExpression<U> arg); ExpressionBuilder<String,N> concat(Function1<R,U> getter); ExpressionBuilder<String,N> concat(FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, FunctionOptional1<R,U> getter); ExpressionBuilder<T,N> selectivity(double v); static ExpressionBuilder<T,N> of(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); }
|
@Test void label() { when(expression1.label(scope)).thenReturn("freddy"); ExpressionBuilder<String,BooleanExpression> sut = ExpressionBuilder.of(expression1, e -> e); String result = sut.label(scope); assertThat(result, is("freddy")); verify(expression1).label(scope); verifyNoMoreInteractions(expression1, scope); }
|
SelectStatement { Stream<Object> args(Scope outerScope) { Scope innerScope = outerScope.plus(scope); return Stream.of( cteArgs(outerScope), projection.args(innerScope), from.args(innerScope), whereClauseArgs(innerScope), groupByClauseArgs(innerScope), havingClauseArgs(innerScope), unionsArgs(innerScope) ).flatMap(Function.identity()); } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }
|
@Test void args() { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); when(projection.args(any())).thenReturn(Stream.of("ABC")); when(from.args(any())).thenReturn(Stream.of(1, 2.4)); Stream<Object> result = sut.args(sut.scope()); assertThat(result.toArray(), arrayContaining("ABC", 1, 2.4)); }
|
ExpressionBuilder implements TypedExpression<T> { @Override public RowMapper<T> rowMapper(Scope scope, Optional<String> label) { return lhs.rowMapper(scope, label); } protected ExpressionBuilder(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); @Override String toString(); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); N isEqualTo(T value); N isEqualTo(TypedExpression<T> expression); N isEqualTo(Function1<R,T> getter); N isEqualTo(FunctionOptional1<R,T> getter); N isEqualTo(String alias, Function1<R,T> getter); N isEqualTo(String alias, FunctionOptional1<R,T> getter); N isEqualTo(Alias<R> alias, Function1<R,T> getter); N isEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isNotEqualTo(T value); N isNotEqualTo(TypedExpression<T> expression); N isNotEqualTo(Function1<R,T> getter); N isNotEqualTo(FunctionOptional1<R,T> getter); N isNotEqualTo(String alias, Function1<R,T> getter); N isNotEqualTo(String alias, FunctionOptional1<R,T> getter); N isNotEqualTo(Alias<R> alias, Function1<R,T> getter); N isNotEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThan(T value); N isGreaterThan(TypedExpression<T> expression); N isGreaterThan(Function1<R,T> getter); N isGreaterThan(FunctionOptional1<R,T> getter); N isGreaterThan(String alias, Function1<R,T> getter); N isGreaterThan(String alias, FunctionOptional1<R,T> getter); N isGreaterThan(Alias<R> alias, Function1<R,T> getter); N isGreaterThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThan(T value); N isLessThan(TypedExpression<T> expression); N isLessThan(Function1<R,T> getter); N isLessThan(FunctionOptional1<R,T> getter); N isLessThan(String alias, Function1<R,T> getter); N isLessThan(String alias, FunctionOptional1<R,T> getter); N isLessThan(Alias<R> alias, Function1<R,T> getter); N isLessThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(T value); N isGreaterThanOrEqualTo(TypedExpression<T> expression); N isGreaterThanOrEqualTo(Function1<R,T> getter); N isGreaterThanOrEqualTo(FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(String alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(T value); N isLessThanOrEqualTo(TypedExpression<T> expression); N isLessThanOrEqualTo(Function1<R,T> getter); N isLessThanOrEqualTo(FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(String alias, Function1<R,T> getter); N isLessThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); @SafeVarargs final N isIn(T... values); @SafeVarargs final N isIn(TypedExpression<T>... values); @SafeVarargs final N isNotIn(T... values); @SafeVarargs final N isNotIn(TypedExpression<T>... values); N isIn(Select<T> select); N isNotIn(Select<T> select); N isNull(); N isNotNull(); N isLike(T value); N isLike(T value, String escape); N isLike(TypedExpression<T> value); N isLike(TypedExpression<T> value, String escape); N isNotLike(T value); N isNotLike(T value, String escape); N isNotLike(TypedExpression<T> value); N isNotLike(TypedExpression<T> value, String escape); BetweenBuilder<T,N> isBetween(T value); BetweenBuilder<T,N> isBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isBetween(Function1<R,T> getter); BetweenBuilder<T,N> isBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(T value); BetweenBuilder<T,N> isNotBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isNotBetween(Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, FunctionOptional1<R,T> getter); ExpressionBuilder<String,N> concat(U arg); ExpressionBuilder<String,N> concat(TypedExpression<U> arg); ExpressionBuilder<String,N> concat(Function1<R,U> getter); ExpressionBuilder<String,N> concat(FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, FunctionOptional1<R,U> getter); ExpressionBuilder<T,N> selectivity(double v); static ExpressionBuilder<T,N> of(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); }
|
@Test void rowMapper() { when(expression1.rowMapper(scope, Optional.of("label"))).thenReturn(rowMapper); ExpressionBuilder<String,BooleanExpression> sut = ExpressionBuilder.of(expression1, e -> e); RowMapper<String> result = sut.rowMapper(scope, Optional.of("label")); assertThat(result, sameInstance(rowMapper)); verify(expression1).rowMapper(scope, Optional.of("label")); verifyNoMoreInteractions(expression1, scope); }
|
ExpressionBuilder implements TypedExpression<T> { @SafeVarargs public final N isIn(T... values) { return isOpIn("in", Arrays.stream(values).map(ValueExpression::of).toArray(generator(TypedExpression.class))); } protected ExpressionBuilder(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); @Override String toString(); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); N isEqualTo(T value); N isEqualTo(TypedExpression<T> expression); N isEqualTo(Function1<R,T> getter); N isEqualTo(FunctionOptional1<R,T> getter); N isEqualTo(String alias, Function1<R,T> getter); N isEqualTo(String alias, FunctionOptional1<R,T> getter); N isEqualTo(Alias<R> alias, Function1<R,T> getter); N isEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isNotEqualTo(T value); N isNotEqualTo(TypedExpression<T> expression); N isNotEqualTo(Function1<R,T> getter); N isNotEqualTo(FunctionOptional1<R,T> getter); N isNotEqualTo(String alias, Function1<R,T> getter); N isNotEqualTo(String alias, FunctionOptional1<R,T> getter); N isNotEqualTo(Alias<R> alias, Function1<R,T> getter); N isNotEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThan(T value); N isGreaterThan(TypedExpression<T> expression); N isGreaterThan(Function1<R,T> getter); N isGreaterThan(FunctionOptional1<R,T> getter); N isGreaterThan(String alias, Function1<R,T> getter); N isGreaterThan(String alias, FunctionOptional1<R,T> getter); N isGreaterThan(Alias<R> alias, Function1<R,T> getter); N isGreaterThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThan(T value); N isLessThan(TypedExpression<T> expression); N isLessThan(Function1<R,T> getter); N isLessThan(FunctionOptional1<R,T> getter); N isLessThan(String alias, Function1<R,T> getter); N isLessThan(String alias, FunctionOptional1<R,T> getter); N isLessThan(Alias<R> alias, Function1<R,T> getter); N isLessThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(T value); N isGreaterThanOrEqualTo(TypedExpression<T> expression); N isGreaterThanOrEqualTo(Function1<R,T> getter); N isGreaterThanOrEqualTo(FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(String alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(T value); N isLessThanOrEqualTo(TypedExpression<T> expression); N isLessThanOrEqualTo(Function1<R,T> getter); N isLessThanOrEqualTo(FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(String alias, Function1<R,T> getter); N isLessThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); @SafeVarargs final N isIn(T... values); @SafeVarargs final N isIn(TypedExpression<T>... values); @SafeVarargs final N isNotIn(T... values); @SafeVarargs final N isNotIn(TypedExpression<T>... values); N isIn(Select<T> select); N isNotIn(Select<T> select); N isNull(); N isNotNull(); N isLike(T value); N isLike(T value, String escape); N isLike(TypedExpression<T> value); N isLike(TypedExpression<T> value, String escape); N isNotLike(T value); N isNotLike(T value, String escape); N isNotLike(TypedExpression<T> value); N isNotLike(TypedExpression<T> value, String escape); BetweenBuilder<T,N> isBetween(T value); BetweenBuilder<T,N> isBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isBetween(Function1<R,T> getter); BetweenBuilder<T,N> isBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(T value); BetweenBuilder<T,N> isNotBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isNotBetween(Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, FunctionOptional1<R,T> getter); ExpressionBuilder<String,N> concat(U arg); ExpressionBuilder<String,N> concat(TypedExpression<U> arg); ExpressionBuilder<String,N> concat(Function1<R,U> getter); ExpressionBuilder<String,N> concat(FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, FunctionOptional1<R,U> getter); ExpressionBuilder<T,N> selectivity(double v); static ExpressionBuilder<T,N> of(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); }
|
@Test void isInWithNoValuesShouldThrow() { Database database = testDatabase(new AnsiDialect()); ExpressionBuilder<String,InWhereExpectingAnd<SalespersonRow>> select = database.from(SalespersonRow.class) .where(SalespersonRow::firstName); calling(() -> select.isIn(new String[0])) .shouldThrow(IllegalArgumentException.class); }
|
ExpressionBuilder implements TypedExpression<T> { @SafeVarargs public final N isNotIn(T... values) { return isOpIn("not in", Arrays.stream(values).map(ValueExpression::of).toArray(generator(TypedExpression.class))); } protected ExpressionBuilder(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); @Override String toString(); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); N isEqualTo(T value); N isEqualTo(TypedExpression<T> expression); N isEqualTo(Function1<R,T> getter); N isEqualTo(FunctionOptional1<R,T> getter); N isEqualTo(String alias, Function1<R,T> getter); N isEqualTo(String alias, FunctionOptional1<R,T> getter); N isEqualTo(Alias<R> alias, Function1<R,T> getter); N isEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isNotEqualTo(T value); N isNotEqualTo(TypedExpression<T> expression); N isNotEqualTo(Function1<R,T> getter); N isNotEqualTo(FunctionOptional1<R,T> getter); N isNotEqualTo(String alias, Function1<R,T> getter); N isNotEqualTo(String alias, FunctionOptional1<R,T> getter); N isNotEqualTo(Alias<R> alias, Function1<R,T> getter); N isNotEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThan(T value); N isGreaterThan(TypedExpression<T> expression); N isGreaterThan(Function1<R,T> getter); N isGreaterThan(FunctionOptional1<R,T> getter); N isGreaterThan(String alias, Function1<R,T> getter); N isGreaterThan(String alias, FunctionOptional1<R,T> getter); N isGreaterThan(Alias<R> alias, Function1<R,T> getter); N isGreaterThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThan(T value); N isLessThan(TypedExpression<T> expression); N isLessThan(Function1<R,T> getter); N isLessThan(FunctionOptional1<R,T> getter); N isLessThan(String alias, Function1<R,T> getter); N isLessThan(String alias, FunctionOptional1<R,T> getter); N isLessThan(Alias<R> alias, Function1<R,T> getter); N isLessThan(Alias<R> alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(T value); N isGreaterThanOrEqualTo(TypedExpression<T> expression); N isGreaterThanOrEqualTo(Function1<R,T> getter); N isGreaterThanOrEqualTo(FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(String alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isGreaterThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(T value); N isLessThanOrEqualTo(TypedExpression<T> expression); N isLessThanOrEqualTo(Function1<R,T> getter); N isLessThanOrEqualTo(FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(String alias, Function1<R,T> getter); N isLessThanOrEqualTo(String alias, FunctionOptional1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, Function1<R,T> getter); N isLessThanOrEqualTo(Alias<R> alias, FunctionOptional1<R,T> getter); @SafeVarargs final N isIn(T... values); @SafeVarargs final N isIn(TypedExpression<T>... values); @SafeVarargs final N isNotIn(T... values); @SafeVarargs final N isNotIn(TypedExpression<T>... values); N isIn(Select<T> select); N isNotIn(Select<T> select); N isNull(); N isNotNull(); N isLike(T value); N isLike(T value, String escape); N isLike(TypedExpression<T> value); N isLike(TypedExpression<T> value, String escape); N isNotLike(T value); N isNotLike(T value, String escape); N isNotLike(TypedExpression<T> value); N isNotLike(TypedExpression<T> value, String escape); BetweenBuilder<T,N> isBetween(T value); BetweenBuilder<T,N> isBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isBetween(Function1<R,T> getter); BetweenBuilder<T,N> isBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isBetween(Alias<R> alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(T value); BetweenBuilder<T,N> isNotBetween(TypedExpression<T> expression); BetweenBuilder<T,N> isNotBetween(Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(String alias, FunctionOptional1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, Function1<R,T> getter); BetweenBuilder<T,N> isNotBetween(Alias<R> alias, FunctionOptional1<R,T> getter); ExpressionBuilder<String,N> concat(U arg); ExpressionBuilder<String,N> concat(TypedExpression<U> arg); ExpressionBuilder<String,N> concat(Function1<R,U> getter); ExpressionBuilder<String,N> concat(FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(String alias, FunctionOptional1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, Function1<R,U> getter); ExpressionBuilder<String,N> concat(Alias<R> alias, FunctionOptional1<R,U> getter); ExpressionBuilder<T,N> selectivity(double v); static ExpressionBuilder<T,N> of(TypedExpression<T> lhs, Function<BooleanExpression,N> onComplete); }
|
@Test void isNotInWithNoValuesShouldThrow() { Database database = testDatabase(new AnsiDialect()); ExpressionBuilder<String,InWhereExpectingAnd<SalespersonRow>> select = database.from(SalespersonRow.class) .where(SalespersonRow::firstName); calling(() -> select.isNotIn(new String[0])) .shouldThrow(IllegalArgumentException.class); }
|
CaseExpression implements TypedExpression<T> { @Override public String sql(Scope scope) { return String.format("case %s%s end", cases.stream().map(c -> String.format("when %s then %s", c.item1().sql(scope), c.item2().sql(scope))).collect(joining(" ")), orElse.map(e -> " else " + e.sql(scope)).orElse("")); } CaseExpression(BooleanExpression booleanExpression, TypedExpression<T> value); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); TypedExpression<T> orElse(T value); TypedExpression<T> orElse(TypedExpression<T> value); TypedExpression<T> orElse(Function1<R,T> method); TypedExpression<T> orElse(FunctionOptional1<R,T> method); TypedExpression<T> orElse(String alias, Function1<R,T> method); TypedExpression<T> orElse(String alias, FunctionOptional1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, Function1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, FunctionOptional1<R,T> method); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(X val); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(TypedExpression<X> expression); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, FunctionOptional1<X,R> method); }
|
@Test void sql() { CaseExpression<String> sut = new CaseExpression<>(condition, expression1); when(condition.sql(scope)).thenReturn("CONDITION"); when(expression1.sql(scope)).thenReturn("EXPRESSION"); String sql = sut.sql(scope); assertThat(sql, is("case when CONDITION then EXPRESSION end")); verifyNoMoreInteractions(condition, expression1, scope); }
|
CaseExpression implements TypedExpression<T> { @Override public Stream<Object> args(Scope scope) { return Stream.concat( cases.stream().flatMap(c -> Stream.concat(c.item1().args(scope), c.item2().args(scope))), StreamUtil.of(orElse).flatMap(e -> e.args(scope)) ); } CaseExpression(BooleanExpression booleanExpression, TypedExpression<T> value); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); TypedExpression<T> orElse(T value); TypedExpression<T> orElse(TypedExpression<T> value); TypedExpression<T> orElse(Function1<R,T> method); TypedExpression<T> orElse(FunctionOptional1<R,T> method); TypedExpression<T> orElse(String alias, Function1<R,T> method); TypedExpression<T> orElse(String alias, FunctionOptional1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, Function1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, FunctionOptional1<R,T> method); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(X val); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(TypedExpression<X> expression); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, FunctionOptional1<X,R> method); }
|
@Test void args() { CaseExpression<String> sut = new CaseExpression<>(condition, expression1); when(condition.args(scope)).thenReturn(Stream.of(1, "2")); when(expression1.args(scope)).thenReturn(Stream.of(3.0, BigDecimal.TEN)); Object[] args = sut.args(scope).toArray(); assertThat(args, arrayContaining(1, "2", 3.0, BigDecimal.TEN)); verifyNoMoreInteractions(condition, expression1, scope); }
|
CaseExpression implements TypedExpression<T> { @Override public Precedence precedence() { return Precedence.UNARY; } CaseExpression(BooleanExpression booleanExpression, TypedExpression<T> value); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); TypedExpression<T> orElse(T value); TypedExpression<T> orElse(TypedExpression<T> value); TypedExpression<T> orElse(Function1<R,T> method); TypedExpression<T> orElse(FunctionOptional1<R,T> method); TypedExpression<T> orElse(String alias, Function1<R,T> method); TypedExpression<T> orElse(String alias, FunctionOptional1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, Function1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, FunctionOptional1<R,T> method); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(X val); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(TypedExpression<X> expression); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, FunctionOptional1<X,R> method); }
|
@Test void precedence() { CaseExpression<String> sut = new CaseExpression<>(condition, expression1); Precedence precedence = sut.precedence(); assertThat(precedence, is(Precedence.UNARY)); verifyNoMoreInteractions(condition, expression1, scope); }
|
CaseExpression implements TypedExpression<T> { @Override public String label(Scope scope) { return labelGenerator.label(scope); } CaseExpression(BooleanExpression booleanExpression, TypedExpression<T> value); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); TypedExpression<T> orElse(T value); TypedExpression<T> orElse(TypedExpression<T> value); TypedExpression<T> orElse(Function1<R,T> method); TypedExpression<T> orElse(FunctionOptional1<R,T> method); TypedExpression<T> orElse(String alias, Function1<R,T> method); TypedExpression<T> orElse(String alias, FunctionOptional1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, Function1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, FunctionOptional1<R,T> method); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(X val); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(TypedExpression<X> expression); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, FunctionOptional1<X,R> method); }
|
@Test void label() { CaseExpression<String> sut1 = new CaseExpression<>(condition, expression1); CaseExpression<String> sut2 = new CaseExpression<>(condition, expression2); when(scope.newLabel()).thenReturn(1L).thenReturn(2L); String label1 = sut1.label(scope); String label2 = sut1.label(scope); String label3 = sut2.label(scope); assertThat(label1, is(label2)); assertThat(label1, not(is(label3))); assertThat(label1, startsWith("case_")); assertThat(label3, startsWith("case_")); verifyNoMoreInteractions(condition, expression1, expression2, scope); }
|
CaseExpression implements TypedExpression<T> { @Override public RowMapper<T> rowMapper(Scope scope, Optional<String> label) { return cases.get(0).item2().rowMapper(scope, Optional.of(label.orElseGet(() -> label(scope)))); } CaseExpression(BooleanExpression booleanExpression, TypedExpression<T> value); @Override String sql(Scope scope); @Override Stream<Object> args(Scope scope); @Override Precedence precedence(); @Override String label(Scope scope); @Override RowMapper<T> rowMapper(Scope scope, Optional<String> label); @Override TypeToken<T> type(); TypedExpression<T> orElse(T value); TypedExpression<T> orElse(TypedExpression<T> value); TypedExpression<T> orElse(Function1<R,T> method); TypedExpression<T> orElse(FunctionOptional1<R,T> method); TypedExpression<T> orElse(String alias, Function1<R,T> method); TypedExpression<T> orElse(String alias, FunctionOptional1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, Function1<R,T> method); TypedExpression<T> orElse(Alias<R> alias, FunctionOptional1<R,T> method); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(X val); ExpressionBuilder<X,InSubsequentWhenExpectingThen> when(TypedExpression<X> expression); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(String alias, FunctionOptional1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, Function1<X,R> method); ExpressionBuilder<R,InSubsequentWhenExpectingThen> when(Alias<X> alias, FunctionOptional1<X,R> method); }
|
@Test void rowMapper() { CaseExpression<String> sut = new CaseExpression<>(condition, expression1); when(expression1.rowMapper(scope, Optional.of("test_case"))).thenReturn(rowMapper); RowMapper<String> result = sut.rowMapper(scope, Optional.of("test_case")); assertThat(result, sameInstance(rowMapper)); verifyNoMoreInteractions(condition, expression1, scope); }
|
Sequence { public SequenceExpression<T> nextVal() { return new SequenceExpression<>(this); } private Sequence(Builder<T> builder); SequenceExpression<T> nextVal(); T single(); TypeToken<T> type(); RowMapper<T> rowMapper(String label); String name(); String sql(); static Builder<T> newBuilder(); }
|
@Test void nextVal() { when(database.dialect()).thenReturn(dialect); when(dialect.nextFromSequence("TOM", "MYSCHEMA", "TEST_SEQ")).thenReturn("select next value from TEST_SEQ"); Sequence<Integer> sut = createSut(); SequenceExpression<Integer> result = sut.nextVal(); assertThat(result.sql(new Scope(database)), is("select next value from TEST_SEQ")); }
|
Sequence { public T single() { return single(database.getDefaultSqlExecutor()); } private Sequence(Builder<T> builder); SequenceExpression<T> nextVal(); T single(); TypeToken<T> type(); RowMapper<T> rowMapper(String label); String name(); String sql(); static Builder<T> newBuilder(); }
|
@Test void single() { when(database.select(Mockito.<SequenceExpression<Integer>>any(), eq("TEST_SEQ"))).thenReturn(select); when(database.getDefaultSqlExecutor()).thenReturn(sqlExecutor); when(select.single(sqlExecutor)).thenReturn(501); Sequence<Integer> sut = createSut(); Integer single = sut.single(); assertThat(single, is(501)); }
|
SelectStatement { @NotNull private Stream<Object> cteArgs(Scope actualScope) { return actualScope.isOutermost() ? commonTableExpressions().flatMap(cte -> cte.args(actualScope)) : Stream.empty(); } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }
|
@Test void cteArgs() { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); when(projection.args(any())).thenReturn(Stream.of("ABC")); when(from.args(any())).thenReturn(Stream.of(1, 2.4)); when(cte.args(any())).thenReturn(Stream.of("Foo", "Bar")); sut.addCommonTableExpression(cte); Stream<Object> result = sut.args(sut.scope()); assertThat(result.toArray(), arrayContaining("Foo", "Bar", "ABC", 1, 2.4)); }
|
Sequence { public TypeToken<T> type() { return TypeToken.of(dataType.javaClass()); } private Sequence(Builder<T> builder); SequenceExpression<T> nextVal(); T single(); TypeToken<T> type(); RowMapper<T> rowMapper(String label); String name(); String sql(); static Builder<T> newBuilder(); }
|
@Test void type() { Sequence<Integer> sut = createSut(); TypeToken<Integer> result = sut.type(); assertThat(result, is(TypeToken.of(Integer.class))); }
|
Sequence { public RowMapper<T> rowMapper(String label) { return rs -> dataType.get(rs, label, database).orElse(null); } private Sequence(Builder<T> builder); SequenceExpression<T> nextVal(); T single(); TypeToken<T> type(); RowMapper<T> rowMapper(String label); String name(); String sql(); static Builder<T> newBuilder(); }
|
@Test void rowMapper() throws SQLException { when(database.dialect()).thenReturn(dialect); when(dialect.type(DbTypeId.INTEGER)).thenReturn(new DefaultInteger()); when(resultSet.getInt("bob")).thenReturn(1034); Sequence<Integer> sut = createSut(); RowMapper<Integer> result = sut.rowMapper("bob"); assertThat(result, notNullValue()); assertThat(result.mapRow(resultSet), is(1034)); }
|
Sequence { public String sql() { return database.dialect().nextFromSequence(catalog, schema, sequenceName); } private Sequence(Builder<T> builder); SequenceExpression<T> nextVal(); T single(); TypeToken<T> type(); RowMapper<T> rowMapper(String label); String name(); String sql(); static Builder<T> newBuilder(); }
|
@Test void sql() { when(database.dialect()).thenReturn(dialect); when(dialect.nextFromSequence("TOM", "MYSCHEMA", "TEST_SEQ")).thenReturn("get the next sequence value"); Sequence<Integer> sut = createSut(); String result = sut.sql(); assertThat(result, is("get the next sequence value")); }
|
Alias { public String inWhereClause() { if (isDual()) { return table.database().dialect().dual(); } return aliasName .map(a -> String.format("%s %s", table.qualifiedName(), a)) .orElseGet(table::qualifiedName); } protected Alias(Table<R> table, Optional<String> aliasName); @Override boolean equals(Object o); @Override int hashCode(); TypeToken<R> type(); String inWhereClause(); String inSelectClauseSql(String columnName); String inSelectClauseLabel(String columnName); ExpressionBuilder<T,BooleanExpression> column(Function1<R,T> getter); ExpressionBuilder<T,BooleanExpression> column(FunctionOptional1<R,T> getter); Table<R> table(); Optional<String> aliasName(); Column<T,R> column(MethodInfo<R,T> methodInfo); RowMapper<R> rowMapper(); DynamicRowMapper<R> dynamicRowMapper(); static Alias<U> of(Table<U> table); static Alias<U> of(Table<U> table, String aliasName); }
|
@Test void inWhereClause() { when(widgetTable.qualifiedName()).thenReturn("SCHEMA.WIDGET"); when(widgetTable.rowType()).thenReturn(TypeToken.of(WidgetRow.class)); Alias<WidgetRow> sut = Alias.of(widgetTable, "bob"); String result = sut.inWhereClause(); assertThat(result, is("SCHEMA.WIDGET bob")); }
|
Alias { public String inSelectClauseSql(String columnName) { return String.format("%s.%s", aliasName.orElseGet(table::qualifiedName), columnName); } protected Alias(Table<R> table, Optional<String> aliasName); @Override boolean equals(Object o); @Override int hashCode(); TypeToken<R> type(); String inWhereClause(); String inSelectClauseSql(String columnName); String inSelectClauseLabel(String columnName); ExpressionBuilder<T,BooleanExpression> column(Function1<R,T> getter); ExpressionBuilder<T,BooleanExpression> column(FunctionOptional1<R,T> getter); Table<R> table(); Optional<String> aliasName(); Column<T,R> column(MethodInfo<R,T> methodInfo); RowMapper<R> rowMapper(); DynamicRowMapper<R> dynamicRowMapper(); static Alias<U> of(Table<U> table); static Alias<U> of(Table<U> table, String aliasName); }
|
@Test void inSelectClauseSql() { Alias<WidgetRow> sut = Alias.of(widgetTable, "fred"); String result = sut.inSelectClauseSql("WIDGET_ID"); assertThat(result, is("fred.WIDGET_ID")); }
|
Alias { public String inSelectClauseLabel(String columnName) { return String.format("%s_%s", columnLabelPrefix(), columnName); } protected Alias(Table<R> table, Optional<String> aliasName); @Override boolean equals(Object o); @Override int hashCode(); TypeToken<R> type(); String inWhereClause(); String inSelectClauseSql(String columnName); String inSelectClauseLabel(String columnName); ExpressionBuilder<T,BooleanExpression> column(Function1<R,T> getter); ExpressionBuilder<T,BooleanExpression> column(FunctionOptional1<R,T> getter); Table<R> table(); Optional<String> aliasName(); Column<T,R> column(MethodInfo<R,T> methodInfo); RowMapper<R> rowMapper(); DynamicRowMapper<R> dynamicRowMapper(); static Alias<U> of(Table<U> table); static Alias<U> of(Table<U> table, String aliasName); }
|
@Test void inSelectClauseLabel() { Alias<WidgetRow> sut = Alias.of(widgetTable, "fred"); String result = sut.inSelectClauseLabel("WIDGET_ID"); assertThat(result, is("fred_WIDGET_ID")); }
|
JdbcTransaction implements Transaction { Connection connection() { return connection; } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void connection() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); Connection result = sut.connection(); assertThat(result, sameInstance(connection)); verify(connection).setAutoCommit(false); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcTransaction implements Transaction { @Override public void commit() { ConnectionUtil.commit(connection); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void commit() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); sut.commit(); verify(connection).setAutoCommit(false); verify(connection).commit(); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcTransaction implements Transaction { @Override public void rollback() { ConnectionUtil.rollback(connection); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void rollback() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); sut.rollback(); verify(connection).setAutoCommit(false); verify(connection).rollback(); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcTransaction implements Transaction { @Override public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) { return sqlExecutor.query(connection, sql, args, rowMapper); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void query() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); String sql = RandomStringUtils.randomAlphabetic(20, 30); Object[] args = new Object[0]; RowMapper<String> rowMapper = s -> "Hello"; List<String> list = ImmutableList.of("A", "B"); when(sqlExecutor.query(connection, sql, args, rowMapper)).thenReturn(list); List<String> result = sut.query(sql, args, rowMapper); assertThat(result, sameInstance(list)); verify(connection).setAutoCommit(false); verify(sqlExecutor).query(connection, sql, args, rowMapper); verifyNoMoreInteractions(sqlExecutor, connection); }
|
SelectStatement { Projection projection() { return projection; } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }
|
@Test void projection() { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); Projection result = sut.projection(); assertThat(result, sameInstance(projection)); }
|
JdbcTransaction implements Transaction { @Override public <T> Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper) { return autoCloseable.add(sqlExecutor.stream(connection, sql, args, rowMapper, new CompositeAutoCloseable())); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void stream() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); String sql = RandomStringUtils.randomAlphabetic(20, 30); Object[] args = new Object[0]; RowMapper<String> rowMapper = s -> "Hello"; when(sqlExecutor.stream(eq(connection), eq(sql), eq(args), eq(rowMapper), any())).thenReturn(stream); Stream<String> result = sut.stream(sql, args, rowMapper); assertThat(result, sameInstance(stream)); verify(connection).setAutoCommit(false); verify(sqlExecutor).stream(eq(connection), eq(sql), eq(args), eq(rowMapper), any()); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcTransaction implements Transaction { @Override public int update(String sql, Object[] args) { return sqlExecutor.update(connection, sql, args); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void update() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); String sql = RandomStringUtils.randomAlphabetic(20, 30); Object[] args = new Object[0]; int rowsUpdated = RandomValues.randomShort(); when(sqlExecutor.update(connection, sql, args)).thenReturn(rowsUpdated); int result = sut.update(sql, args); assertThat(result, is(rowsUpdated)); verify(connection).setAutoCommit(false); verify(sqlExecutor).update(connection, sql, args); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcTransaction implements Transaction { @Override public void close() { rollback(); autoCloseable.close(); } JdbcTransaction(JdbcSqlExecutor sqlExecutor); @Override void commit(); @Override void rollback(); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override CompletableFuture<List<T>> queryAsync(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); @Override boolean execute(String sql, Object[] args); @Override CompletableFuture<Integer> updateAsync(String sql, Object[] args); @Override void close(); }
|
@Test void close() throws SQLException { when(sqlExecutor.connect()).thenReturn(connection); JdbcTransaction sut = new JdbcTransaction(sqlExecutor); sut.close(); verify(connection).setAutoCommit(false); verify(connection).rollback(); verify(connection).close(); verifyNoMoreInteractions(sqlExecutor, connection); }
|
JdbcSqlExecutor implements SqlExecutor { @Override public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) { try (CompositeAutoCloseable autoCloseable = new CompositeAutoCloseable()) { Connection connection = autoCloseable.add(connect()); return query(connection, sql, args, rowMapper); } } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }
|
@Test void query() throws SQLException { when(preparedStatement.executeQuery()).thenReturn(resultSet); when(resultSet.next()).thenReturn(true).thenReturn(true).thenReturn(false); when(rowMapper.mapRow(resultSet)).thenReturn("Fred").thenReturn("Barney").thenThrow(new AssertionError("Unexpected call to row mapper")); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource); String sql = "select name from foo where bar = ?"; List<String> result = sut.query(connection, sql, toArray(2L), rowMapper); verify(connection).prepareStatement(sql); verify(preparedStatement).executeQuery(); verify(preparedStatement).setObject(1, 2L); verify(preparedStatement).setFetchSize(0); verify(preparedStatement).close(); verify(resultSet, times(3)).next(); verify(resultSet).close(); verify(rowMapper, times(2)).mapRow(resultSet); verifyNoMoreInteractions(connection, preparedStatement, resultSet, rowMapper); assertThat(result, contains("Fred", "Barney")); }
|
JdbcSqlExecutor implements SqlExecutor { @Override public <T> Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper) { CompositeAutoCloseable closeable = new CompositeAutoCloseable(); Connection connection = closeable.add(connect()); return stream(connection, sql, args, rowMapper, closeable); } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }
|
@Test void stream() throws SQLException { CompositeAutoCloseable closeable = new CompositeAutoCloseable(); when(preparedStatement.executeQuery()).thenReturn(resultSet); when(resultSet.next()).thenReturn(true).thenReturn(true).thenReturn(false); when(rowMapper.mapRow(resultSet)).thenReturn("Fred").thenReturn("Barney").thenThrow(new AssertionError("Unexpected call to row mapper")); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource, 100); String sql = "select name from foo where bar = ?"; List<String> result; try (Stream<String> stream = sut.stream(connection, sql, toArray("Bob"), rowMapper, closeable)) { result = stream.collect(Collectors.toList()); } verify(connection).prepareStatement(sql); verify(preparedStatement).executeQuery(); verify(preparedStatement).setObject(1, "Bob"); verify(preparedStatement).setFetchSize(100); verify(preparedStatement).close(); verify(resultSet, times(3)).next(); verify(resultSet).close(); verify(rowMapper, times(2)).mapRow(resultSet); verifyNoMoreInteractions(connection, preparedStatement, resultSet, rowMapper); assertThat(result, contains("Fred", "Barney")); }
|
JdbcSqlExecutor implements SqlExecutor { @Override public int update(String sql, Object[] args) { try (CompositeAutoCloseable autoCloseable = new CompositeAutoCloseable()) { Connection connection = autoCloseable.add(connect()); return update(connection, sql, args); } } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }
|
@Test void update() throws SQLException { when(preparedStatement.executeUpdate()).thenReturn(5); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource); String sql = "update foo set num = ?"; int result = sut.update(connection, sql, toArray(3)); verify(connection).prepareStatement(sql); verify(preparedStatement).executeUpdate(); verify(preparedStatement).setObject(1, 3); verify(preparedStatement).close(); verifyNoMoreInteractions(connection, preparedStatement, resultSet, rowMapper); assertThat(result, is(5)); }
|
JdbcSqlExecutor implements SqlExecutor { @Override public DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable) { Connection connection = autoCloseable.add(connect()); return ConnectionUtil.getMetaData(connection); } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }
|
@Test void metadata() throws SQLException { Mockito.reset(connection); when(dataSource.getConnection()).thenReturn(connection); when(closer.add(connection)).thenReturn(connection); when(connection.getMetaData()).thenReturn(metadata); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource); DatabaseMetaData result = sut.metadata(closer); assertThat(result, sameInstance(metadata)); verify(dataSource, times(1)).getConnection(); verify(closer, times(1)).add(connection); verify(connection, times(1)).getMetaData(); verifyNoMoreInteractions(dataSource, connection, metadata); }
|
SchemaGenerator { public void generate(Database database, SchemaDefinition schemaDefinition) { if (dropFirst) { long dropped = dropAll(database); LOG.debug("Dropped {} objects", dropped); } Stream<Action> actions = Stream.concat( Stream.of(new CreateActionLogTable(database.defaultCatalog(), database.defaultSchema())), schemaDefinition.actions()); long count = pipeline .process(database, actions) .count(); LOG.debug("Processed {} actions", count); } SchemaGenerator(boolean dropFirst); void generate(Database database, SchemaDefinition schemaDefinition); void generate(Database database, Function1<T,SchemaDefinition> schemaDefinition); }
|
@Test void generate() { Database database = TestDatabase.testDatabaseBuilder() .defaultSqlExecutor(JdbcSqlExecutor.of(dataSource())) .dialect(new H2Dialect()) .build(); SchemaGenerator schemaGenerator = new SchemaGenerator(true); schemaGenerator.generate(database, TestSchema::schemaDefinition); schemaGenerator.generate(database, TestSchema::schemaDefinition); SalespersonRow salespersonRow = aRandomSalesperson(); database.insert(salespersonRow); }
|
Database { public <U> InSetExpectingWhere<U> update(Alias<U> alias) { return Update.update(this, alias); } private Database(Builder builder); String defaultCatalog(); String defaultSchema(); NamingStrategy namingStrategy(); Dialect dialect(); Sequence<Integer> sequence(String name); Sequence<T> sequence(Class<T> valueClass, String name); @SuppressWarnings("WeakerAccess") Sequence<T> sequence(Class<T> valueClass, String catalog, String schema, String name); UncheckedAutoCloseable withLockTimeout(long time, TimeUnit unit); @SuppressWarnings("WeakerAccess") UncheckedAutoCloseable withLockTimeout(SqlExecutor executor, long time, TimeUnit unit); UncheckedAutoCloseable withLockTimeout(Transaction transaction, long time, TimeUnit unit); @SuppressWarnings("unchecked") Table<R> table(Class<R> rowClass); Table<R> table(TypeToken<R> rowType); ZoneId databaseTimeZone(); T execute(String sql, Supplier<T> statement); T translateException(String sql, Throwable throwable); String columnNameFor(MethodInfo<R,T> getterMethod); String columnNameFor(FieldInfo<R,T> fieldInfo); DataType<T> getDataTypeOf(MethodInfo<R,T> getterInfo); DataType<T> getDataTypeOf(T value); DataType<T> getDataTypeOf(Class<T> valueClass); DataType<T> getDataTypeOf(TypeToken<T> valueClass); @SuppressWarnings("WeakerAccess") Optional<DataType<T>> dataTypeOf(MethodInfo<R,T> getterInfo); Optional<DataType<T>> dataTypeOf(FieldInfo<R,T> fieldInfo); Column<T,R> column(Function1<R,T> getter); Column<T,R> column(FunctionOptional1<R,T> getter); Column<T,R> column(MethodInfo<R,T> methodInfo); SqlExecutor getDefaultSqlExecutor(); Transaction beginTransaction(); CommonTableExpressionBuilder with(String name); InProjectionExpectingComma1<T> select(TypedExpression<T> what); InProjectionExpectingComma1<T> select(TypedExpression<T> what, String label); ExpectingJoin1<R> from(Class<R> rowClass); ExpectingJoin1<R> from(Alias<R> alias); ExpectingJoin1<R> from(CommonTableExpression<R> cte, String aliasName); ExpectingJoin1<R> from(CommonTableExpression<R> cte); ExpectingJoin1<R> from(Class<R> rowClass, String alias); @SuppressWarnings("unchecked") int insert(R... rows); @SuppressWarnings("unchecked") int insert(SqlExecutor sqlExecutor, R... rows); @SuppressWarnings("unchecked") int insert(Transaction transaction, R... rows); InSetExpectingWhere<U> update(Alias<U> alias); InSetExpectingWhere<U> update(Class<U> rowClass); InSetExpectingWhere<U> update(Class<U> rowClass, String alias); @SuppressWarnings("UnusedReturnValue") int update(R row); @SuppressWarnings("unchecked") int update(SqlExecutor sqlExecutor, R row); @SuppressWarnings({"unchecked", "UnusedReturnValue"}) int update(Transaction transaction, R row); ExpectingWhere delete(Alias<D> alias); ExpectingWhere delete(Class<D> rowClass); ExpectingWhere delete(Class<D> rowClass, String alias); @SuppressWarnings("UnusedReturnValue") int delete(R row); @SuppressWarnings("unchecked") int delete(SqlExecutor sqlExecutor, R row); @SuppressWarnings({"unchecked", "UnusedReturnValue"}) int delete(Transaction transaction, R row); static Builder newBuilder(); }
|
@Test void update() { Database database = Database.newBuilder() .defaultSqlExecutor(sqlExecutor) .build(); SalespersonRow salesperson = IntegrationTest.aRandomSalesperson(); database.update(salesperson); verify(sqlExecutor).update(sqlCaptor.capture(), argCaptor.capture()); assertThat(sqlCaptor.getValue(), is("update SIESTA.SALESPERSON " + "set FIRST_NAME = ?, MIDDLE_NAMES = ?, SURNAME = ?, NUMBER_OF_SALES = ?, COMMISSION = ? " + "where SIESTA.SALESPERSON.SALESPERSON_ID = ?")); assertThat(argCaptor.getValue(), arrayContaining( salesperson.firstName(), salesperson.middleNames().orElse(null), salesperson.surname(), salesperson.numberOfSales(), salesperson.commission().orElse(null), salesperson.salespersonId() )); }
|
Database { public <D> ExpectingWhere delete(Alias<D> alias) { return Delete.delete(this, alias); } private Database(Builder builder); String defaultCatalog(); String defaultSchema(); NamingStrategy namingStrategy(); Dialect dialect(); Sequence<Integer> sequence(String name); Sequence<T> sequence(Class<T> valueClass, String name); @SuppressWarnings("WeakerAccess") Sequence<T> sequence(Class<T> valueClass, String catalog, String schema, String name); UncheckedAutoCloseable withLockTimeout(long time, TimeUnit unit); @SuppressWarnings("WeakerAccess") UncheckedAutoCloseable withLockTimeout(SqlExecutor executor, long time, TimeUnit unit); UncheckedAutoCloseable withLockTimeout(Transaction transaction, long time, TimeUnit unit); @SuppressWarnings("unchecked") Table<R> table(Class<R> rowClass); Table<R> table(TypeToken<R> rowType); ZoneId databaseTimeZone(); T execute(String sql, Supplier<T> statement); T translateException(String sql, Throwable throwable); String columnNameFor(MethodInfo<R,T> getterMethod); String columnNameFor(FieldInfo<R,T> fieldInfo); DataType<T> getDataTypeOf(MethodInfo<R,T> getterInfo); DataType<T> getDataTypeOf(T value); DataType<T> getDataTypeOf(Class<T> valueClass); DataType<T> getDataTypeOf(TypeToken<T> valueClass); @SuppressWarnings("WeakerAccess") Optional<DataType<T>> dataTypeOf(MethodInfo<R,T> getterInfo); Optional<DataType<T>> dataTypeOf(FieldInfo<R,T> fieldInfo); Column<T,R> column(Function1<R,T> getter); Column<T,R> column(FunctionOptional1<R,T> getter); Column<T,R> column(MethodInfo<R,T> methodInfo); SqlExecutor getDefaultSqlExecutor(); Transaction beginTransaction(); CommonTableExpressionBuilder with(String name); InProjectionExpectingComma1<T> select(TypedExpression<T> what); InProjectionExpectingComma1<T> select(TypedExpression<T> what, String label); ExpectingJoin1<R> from(Class<R> rowClass); ExpectingJoin1<R> from(Alias<R> alias); ExpectingJoin1<R> from(CommonTableExpression<R> cte, String aliasName); ExpectingJoin1<R> from(CommonTableExpression<R> cte); ExpectingJoin1<R> from(Class<R> rowClass, String alias); @SuppressWarnings("unchecked") int insert(R... rows); @SuppressWarnings("unchecked") int insert(SqlExecutor sqlExecutor, R... rows); @SuppressWarnings("unchecked") int insert(Transaction transaction, R... rows); InSetExpectingWhere<U> update(Alias<U> alias); InSetExpectingWhere<U> update(Class<U> rowClass); InSetExpectingWhere<U> update(Class<U> rowClass, String alias); @SuppressWarnings("UnusedReturnValue") int update(R row); @SuppressWarnings("unchecked") int update(SqlExecutor sqlExecutor, R row); @SuppressWarnings({"unchecked", "UnusedReturnValue"}) int update(Transaction transaction, R row); ExpectingWhere delete(Alias<D> alias); ExpectingWhere delete(Class<D> rowClass); ExpectingWhere delete(Class<D> rowClass, String alias); @SuppressWarnings("UnusedReturnValue") int delete(R row); @SuppressWarnings("unchecked") int delete(SqlExecutor sqlExecutor, R row); @SuppressWarnings({"unchecked", "UnusedReturnValue"}) int delete(Transaction transaction, R row); static Builder newBuilder(); }
|
@Test void delete() { Database database = Database.newBuilder() .defaultSqlExecutor(sqlExecutor) .build(); SalespersonRow salesperson = IntegrationTest.aRandomSalesperson(); database.delete(salesperson); verify(sqlExecutor).update(sqlCaptor.capture(), argCaptor.capture()); assertThat(sqlCaptor.getValue(), is("delete from SIESTA.SALESPERSON " + "where SIESTA.SALESPERSON.SALESPERSON_ID = ?")); assertThat(argCaptor.getValue(), arrayContaining(salesperson.salespersonId())); }
|
SelectStatement { void fetchFirst(long i) { fetchFirst = Optional.of(i); } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }
|
@Test void fetchFirst() { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); when(projection.sql(any())).thenReturn("*"); when(from.sql(any())).thenReturn(" from bob"); sut.fetchFirst(4L); assertThat(sut.sql(), is("select * from bob fetch first 4 rows only")); }
|
ArrayUtil extends UtilityClass { @SuppressWarnings("unchecked") public static <T> T[] newArray(Class<T> elementType, int size) { return (T[]) Array.newInstance(elementType, size); } @SuppressWarnings("unchecked") static T[] newArray(Class<T> elementType, int size); @SuppressWarnings("unchecked") static T[] newArray(TypeToken<T> elementType, int size); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(Class<? super T> elementClass); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(T prototype); @SuppressWarnings("unchecked") static T[] arrayOf(int size, T value); static char[] arrayOf(int size, char value); static boolean[] arrayOf(int size, boolean value); static byte[] arrayOf(int size, byte value); static short[] arrayOf(int size, short value); static int[] arrayOf(int size, int value); static long[] arrayOf(int size, long value); static float[] arrayOf(int size, float value); static double[] arrayOf(int size, double value); static Stream<Boolean> stream(boolean[] booleans); static Stream<Byte> stream(byte[] bytes); static Stream<Character> stream(char[] chars); static Stream<Short> stream(short[] shorts); static Stream<Float> stream(float[] floats); }
|
@Test void newArrayClass() { int size = RandomUtils.nextInt(5, 20); ZonedDateTime[] result = ArrayUtil.newArray(ZonedDateTime.class, size); assertThat(result, arrayWithSize(size)); }
@Test void newArrayTypeToken() { int size = RandomUtils.nextInt(5, 20); List<Integer>[] result = ArrayUtil.newArray(new TypeToken<List<Integer>>() {}, size); assertThat(result, arrayWithSize(size)); }
|
ArrayUtil extends UtilityClass { @SuppressWarnings("unchecked") public static <T> IntFunction<T[]> generator(Class<? super T> elementClass) { return size -> (T[])ArrayUtil.newArray(elementClass, size); } @SuppressWarnings("unchecked") static T[] newArray(Class<T> elementType, int size); @SuppressWarnings("unchecked") static T[] newArray(TypeToken<T> elementType, int size); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(Class<? super T> elementClass); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(T prototype); @SuppressWarnings("unchecked") static T[] arrayOf(int size, T value); static char[] arrayOf(int size, char value); static boolean[] arrayOf(int size, boolean value); static byte[] arrayOf(int size, byte value); static short[] arrayOf(int size, short value); static int[] arrayOf(int size, int value); static long[] arrayOf(int size, long value); static float[] arrayOf(int size, float value); static double[] arrayOf(int size, double value); static Stream<Boolean> stream(boolean[] booleans); static Stream<Byte> stream(byte[] bytes); static Stream<Character> stream(char[] chars); static Stream<Short> stream(short[] shorts); static Stream<Float> stream(float[] floats); }
|
@Test void generator() { int size = RandomUtils.nextInt(5, 20); IntFunction<List<String>[]> result = ArrayUtil.generator(List.class); assertThat(result.apply(size), arrayWithSize(size)); }
|
ArrayUtil extends UtilityClass { public static Stream<Boolean> stream(boolean[] booleans) { return IntStream.range(0, booleans.length).mapToObj(i -> booleans[i]); } @SuppressWarnings("unchecked") static T[] newArray(Class<T> elementType, int size); @SuppressWarnings("unchecked") static T[] newArray(TypeToken<T> elementType, int size); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(Class<? super T> elementClass); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(T prototype); @SuppressWarnings("unchecked") static T[] arrayOf(int size, T value); static char[] arrayOf(int size, char value); static boolean[] arrayOf(int size, boolean value); static byte[] arrayOf(int size, byte value); static short[] arrayOf(int size, short value); static int[] arrayOf(int size, int value); static long[] arrayOf(int size, long value); static float[] arrayOf(int size, float value); static double[] arrayOf(int size, double value); static Stream<Boolean> stream(boolean[] booleans); static Stream<Byte> stream(byte[] bytes); static Stream<Character> stream(char[] chars); static Stream<Short> stream(short[] shorts); static Stream<Float> stream(float[] floats); }
|
@Test void streamBoolean() { boolean[] booleans = RandomValues.randomBooleanArray(10, 20); Boolean[] resultAsArray = ArrayUtil.stream(booleans).toArray(Boolean[]::new); assertThat(resultAsArray.length, is(booleans.length)); for (int i = 0; i < resultAsArray.length; i++) { assertThat(resultAsArray[i], is(booleans[i])); } }
@Test void streamByte() { byte[] bytes = RandomValues.randomByteArray(10, 20); Byte[] resultAsArray = ArrayUtil.stream(bytes).toArray(Byte[]::new); assertThat(resultAsArray.length, is(bytes.length)); for (int i = 0; i < resultAsArray.length; i++) { assertThat(resultAsArray[i], is(bytes[i])); } }
@Test void streamChar() { char[] chars = RandomValues.randomCharArray(10, 20); Character[] resultAsArray = ArrayUtil.stream(chars).toArray(Character[]::new); assertThat(resultAsArray.length, is(chars.length)); for (int i = 0; i < resultAsArray.length; i++) { assertThat(resultAsArray[i], is(chars[i])); } }
@Test void streamShort() { short[] shorts = RandomValues.randomShortArray(10, 20); Short[] resultAsArray = ArrayUtil.stream(shorts).toArray(Short[]::new); assertThat(resultAsArray.length, is(shorts.length)); for (int i = 0; i < resultAsArray.length; i++) { assertThat(resultAsArray[i], is(shorts[i])); } }
@Test void streamFloat() { float[] shorts = RandomValues.randomFloatArray(10, 20); Float[] resultAsArray = ArrayUtil.stream(shorts).toArray(Float[]::new); assertThat(resultAsArray.length, is(shorts.length)); for (int i = 0; i < resultAsArray.length; i++) { assertThat(resultAsArray[i], is(shorts[i])); } }
|
Try { public static <T, E extends Throwable> Try<T> trySupply(ThrowingSupplier<? extends T,E> supplier) { requireNonNull(supplier); try { return success(supplier.get()); } catch (Throwable e) { return failure(e); } } abstract boolean isSuccess(); abstract boolean isFailure(); abstract T orElseThrow(); abstract Throwable throwable(); abstract Try<U> map(ThrowingFunction<? super T,? extends U,? extends E> function); abstract Try<U> flatMap(ThrowingFunction<? super T,Try<U>,? extends E> function); abstract Try<R> combine(Try<U> other, ThrowingFunction2<? super T,? super U,? extends R,? extends E> function); abstract T orElse(T alternativeValue); abstract T orElseGet(Supplier<T> supplier); abstract Try<T> orElseTry(ThrowingSupplier<T,? extends E> supplier); abstract T orElseThrow(Supplier<? extends X> exceptionSupplier); abstract Try<T> throwIfError(); abstract Try<T> ifSuccess(Consumer<? super T> consumer); abstract Try<T> ifFailure(Consumer<? super Throwable> consumer); abstract Optional<T> toOptional(); abstract Stream<T> stream(); static Try<T> trySupply(ThrowingSupplier<? extends T,E> supplier); static Try<T> success(T value); static Try<T> failure(Throwable e); }
|
@Test void trySupplyWithNullSupplier() { calling(() -> Try.trySupply(null)) .shouldThrow(NullPointerException.class); }
|
OptionalUtil extends UtilityClass { public static <T extends CharSequence> Optional<T> ofBlankable(T s) { return StringUtils.isBlank(s) ? Optional.empty() : Optional.of(s); } static Optional<T> ofBlankable(T s); static Optional<T> ofOnly(Iterable<T> iterable); static OptionalWrapper<T> with(Optional<T> optional); static Optional<T> or(Optional<T> optional, Optional<T> other); static Optional<T> orGet(Optional<T> optional, Supplier<? extends Optional<? extends T>> supplier); static Optional<U> as(Class<U> targetClass, Optional<T> source); @SuppressWarnings("unchecked") static Optional<U> as(TypeToken<U> targetType, Optional<T> source); static Optional<U> as(Class<U> targetClass, T source); @SuppressWarnings("unchecked") static Optional<U> as(TypeToken<U> targetType, T source); }
|
@ParameterizedTest @ArgumentsSource(TestCaseArgumentsProvider.class) @TestCase({"null", "empty"}) @TestCase({"", "empty"}) @TestCase({"\n", "empty"}) @TestCase({" ", "empty"}) @TestCase({"\f\r\n ", "empty"}) @TestCase({"x", "x"}) void ofBlankable(String input, Optional<String> expected) { Optional<String> result = OptionalUtil.ofBlankable(input); assertThat(result, is(expected)); }
|
SelectStatement { void withIsolation(IsolationLevel level) { isolationLevel = level; } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }
|
@ParameterizedTest @ArgumentsSource(TestCaseArgumentsProvider.class) @TestCase({"UNSPECIFIED", ""}) @TestCase({"UNCOMMITTED_READ", " with ur"}) @TestCase({"READ_COMMITTED", " with cs"}) @TestCase({"REPEATABLE_READ", " with rs"}) @TestCase({"SERIALIZABLE", " with rr"}) void withIsolation(IsolationLevel isolation, String isolationSql) { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); sut.withIsolation(isolation); when(projection.sql(any())).thenReturn("col1"); when(from.sql(any())).thenReturn(" from tab1"); assertThat(sut.sql(), is("select col1 from tab1" + isolationSql)); }
|
TypeChecker implements StatementVisitor<Type, String>, ExpressionVisitor<Type, String>, TypeVisitor<Type, String> { public ErrorLogger checkExpressionTypes(Form form, TypeTable typeTable) { this.typeTable = typeTable; for (Statement statement : form.getStatements()) { statement.accept(this, null); } return logger; } TypeChecker(); ErrorLogger checkExpressionTypes(Form form, TypeTable typeTable); @Override Type visit(Question question, String context); @Override Type visit(IfStatement ifStatement, String context); @Override Type visit(IfElseStatement ifElseStatement, String context); @Override Type visit(CalculatedQuestion calculatedQuestion, String context); @Override Type visit(StringLiteral stringLiteral, String context); @Override Type visit(IntegerLiteral integerLiteral, String context); @Override Type visit(BooleanLiteral booleanLiteral, String context); @Override Type visit(Parameter parameter, String context); @Override Type visit(ParameterGroup parameterGroup, String context); @Override Type visit(Addition addition, String context); @Override Type visit(Subtraction subtraction, String context); @Override Type visit(Multiplication multiplication, String context); @Override Type visit(Division division, String context); @Override Type visit(Equal equal, String context); @Override Type visit(NotEqual notEqual, String context); @Override Type visit(GreaterThan greaterThan, String context); @Override Type visit(GreaterThanEqualTo greaterThanEqualTo, String context); @Override Type visit(LessThan lessThan, String context); @Override Type visit(LessThanEqualTo lessThanEqualTo, String context); @Override Type visit(LogicalAnd logicalAnd, String context); @Override Type visit(LogicalOr logicalOr, String context); @Override Type visit(Negation negation, String context); @Override Type visit(BooleanType booleanType, String context); @Override Type visit(StringType stringType, String context); @Override Type visit(ErrorType errorType, String context); @Override Type visit(IntegerType integerType, String context); }
|
@Test public void checkTypeChecker() { final int EXPECTED_RESULT = 2; QLParser parser = ASTBuilder.getQlParser("form testform { \"test1\" test1:boolean; \"test2\" test2:integer = 12 + test1"); Form form = ASTBuilder.getForm(parser); TypeTable typeTable = new TypeTable(); typeTable.addEntry("test1", new BooleanType()); typeTable.addEntry("test2", new IntegerType()); TypeChecker checker = new TypeChecker(); ErrorLogger logger = checker.checkExpressionTypes(form, typeTable); assertEquals(EXPECTED_RESULT, logger.getErrorNumber()); }
|
TypeChecker implements FormVisitor<Void>, ItemVisitor<Void>, ExpressionVisitor<ValueType> { @Override public Void visit(Form node) { for (Item item : node.getQuestions()) { item.accept(this); } return null; } TypeChecker(Messages messages); @Override Void visit(Form node); @Override Void visit(Question node); @Override Void visit(ComputedQuestion computedQuestion); @Override Void visit(IfThen node); @Override Void visit(IfThenElse node); @Override ValueType visit(GroupedExpression node); @Override ValueType visit(Identifier identifier); @Override ValueType visit(StringerLiteral stringerLiteral); @Override ValueType visit(IntegerLiteral integerLiteral); @Override ValueType visit(BooleanLiteral booleanLiteral); @Override ValueType visit(Expression expression); @Override ValueType visit(Addition addition); @Override ValueType visit(Division division); @Override ValueType visit(Equal equal); @Override ValueType visit(GreaterThan greaterThan); @Override ValueType visit(GreaterThanOrEqual greaterThanOrEqual); @Override ValueType visit(LessThan lessThan); @Override ValueType visit(LessThanOrEqual lessThanOrEqual); @Override ValueType visit(LogicalAnd logicalAnd); @Override ValueType visit(LogicalOr logicalOr); @Override ValueType visit(Multiplication multiplication); @Override ValueType visit(NotEqual notEqual); @Override ValueType visit(Subtraction subtraction); }
|
@Test public void testInvalidOperandsTypeToOperatorNotEqual() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); NotEqual notEqual = new NotEqual(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(notEqual); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorSubtraction() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); Subtraction subtraction = new Subtraction(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(subtraction); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testDuplicateLabel() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"Same label question\" hasSoldHouse: string \"Same label question\" sellingPrice: money }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question q1 = (Question) questions.get(0); Question q2 = (Question) questions.get(1); typeChecker.visit(q1); typeChecker.visit(q2); assertEquals(0, messages.getErrors().size()); assertEquals(1, messages.getWarnings().size()); assertEquals("Duplicate question label at line 1: Label: Same label question", messages.getWarnings().get(0).getMessage()); }
@Test public void testDuplicteDeclaration() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"question 1\" var: string \"question 2\" var: money }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question q1 = (Question) questions.get(0); Question q2 = (Question) questions.get(1); typeChecker.visit(q1); typeChecker.visit(q2); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(DuplicateDeclaration.class)); }
@Test public void testUndefinedReference() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"question 1\" var1: string if (unknown) {\"question 2\" var2: money } else {} }"; Form form = ASTGenerator.getForm(qlForm); typeChecker.visit(form); assertEquals(3, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(UndefinedReference.class)); }
@Test public void testOneCyclicDependency() throws IOException { Messages messages = new Messages(); CircularDependencyChecker circularDependencyChecker = new CircularDependencyChecker(messages); String qlForm = "form tax {\n" + " \"q1?\" \n" + " a: integer = (b - 1)\n" + " \"q2?\"\n" + " b: integer = (a / 5)\n" + "}"; Form form = ASTGenerator.getForm(qlForm); circularDependencyChecker.visit(form); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(CyclicDependency.class)); }
@Test public void testTwoCyclicDependencies() throws IOException { Messages messages = new Messages(); CircularDependencyChecker circularDependencyChecker = new CircularDependencyChecker(messages); String qlForm = "form tax {\n" + " \"q1?\"\n" + " b: integer\n" + " \"q2?\"\n" + " a: integer = (b + c)\n" + " \"q3?\"\n" + " c: integer = (a + b)\n" + "}"; Form form = ASTGenerator.getForm(qlForm); circularDependencyChecker.visit(form); assertEquals(2, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(CyclicDependency.class)); assertThat(messages.getErrors().get(1), instanceOf(CyclicDependency.class)); }
@Test public void testStringTypeMismatch() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"question 1\" var1: string if (var1) {\"question 2\" var2: money } }"; Form form = ASTGenerator.getForm(qlForm); typeChecker.visit(form); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(TypeMismatch.class)); }
@Test public void testIntegerTypeMismatch() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"question 1\" var1: integer if (var1) {\"question 2\" var2: money } }"; Form form = ASTGenerator.getForm(qlForm); typeChecker.visit(form); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(TypeMismatch.class)); }
@Test public void testMoneyTypeMismatch() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); String qlForm = "form f1 { \"question 1\" var1: money if (var1) {\"question 2\" var2: money } }"; Form form = ASTGenerator.getForm(qlForm); typeChecker.visit(form); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(TypeMismatch.class)); }
@Test public void testInvalidOperandsTypeToOperatorAddition() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); Addition addition = new Addition(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(addition); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorDivision() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); Division division = new Division(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(division); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorEqual() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); Equal equal = new Equal(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(equal); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorGreaterThan() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); GreaterThan greaterThan = new GreaterThan(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(greaterThan); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorGreaterThanOrEqual() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); GreaterThanOrEqual greaterThanOrEqual = new GreaterThanOrEqual(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(greaterThanOrEqual); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorLessThan() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); LessThan lessThan = new LessThan(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(lessThan); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorLessThanOrEqual() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); LessThanOrEqual lessThanOrEqual = new LessThanOrEqual(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(lessThanOrEqual); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorLogicalAnd() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); LogicalAnd logicalAnd = new LogicalAnd(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); ValueType type = typeChecker.visit(logicalAnd); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorLogicalOr() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); LogicalOr logicalOr = new LogicalOr(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(logicalOr); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
@Test public void testInvalidOperandsTypeToOperatorMultiplication() throws IOException { Messages messages = new Messages(); TypeChecker typeChecker = new TypeChecker(messages); Multiplication multiplication = new Multiplication(2, new StringerLiteral(2, "test"), new IntegerLiteral(2, 111)); typeChecker.visit(multiplication); assertEquals(1, messages.getErrors().size()); assertEquals(0, messages.getWarnings().size()); assertThat(messages.getErrors().get(0), instanceOf(InvalidOperandsTypeToOperator.class)); }
|
Evaluator { public static String calculate(String calculation) throws Exception{ ScriptEngineManager mgr = new ScriptEngineManager(); ScriptEngine engine = mgr.getEngineByName("JavaScript"); return engine.eval(calculation).toString(); } static String calculate(String calculation); }
|
@Test public void testSomeCalculations() throws Exception{ Assert.assertEquals(mEvalutor.calculate("5+5"), "10", "5+5 should equal 10"); }
@Test public void testBooleanExpression() throws Exception{ Assert.assertEquals(mEvalutor.calculate("true == false"), "false", "true is never false"); Assert.assertEquals( mEvalutor.calculate("5 > 0"), "true", "this always holds"); }
|
QuickCount extends Count { public void increment(Integer amount) { super.increment(2 * amount.intValue()); } void increment(Integer amount); }
|
@Test public void testInheritance() throws Exception { Count c = new QuickCount(); c.increment(); Assert.assertEquals(c.getCount(), 2, "Java always calls the overriden method, despite not marking it as abstract"); }
@Test public void testDerivedCall() throws Exception { Count a = new QuickCount(); Number b = new Integer(5); a.increment(b); Assert.assertEquals(a.getCount(), 5, "Overriding only works for equal signatures"); }
|
SampleOperation { public void add(Int a){ a.setValue(10); System.out.println("Called Int"); } void add(Int a); void add(Real a); void add(); }
|
@Test public void testSomeAddition() throws Exception { Num b = new Int(5); SampleOperation s = new SampleOperation(); s.add((Int) b); Assert.assertEquals(((Int) b).getValue(), 10, "Java should automatically grab the proper overload"); }
|
Addition extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " + " + getRight() + ")"; } Addition(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkAdditionParse() { final String EXPECTED_RESULT = "(1 + 2)"; QLParser parser = ASTBuilder.getQlParser("1+2"); Addition expression = (Addition) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkAdditionNestedParse() { final String EXPECTED_RESULT = "((1 + 2) + 3)"; QLParser parser = ASTBuilder.getQlParser("1+2+3"); Addition expression = (Addition) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
LogicalOr extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " || " + getRight() + ")"; } LogicalOr(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkLogicalOrParse() { final String EXPECTED_RESULT = "(1 || 2)"; QLParser parser = ASTBuilder.getQlParser("1||2"); LogicalOr expression = (LogicalOr) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLogicalOrNestedParse() { final String EXPECTED_RESULT = "((1 || 2) || 3)"; QLParser parser = ASTBuilder.getQlParser("1||2||3"); LogicalOr expression = (LogicalOr) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
LessThanEqualTo extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " <= " + getRight() + ")"; } LessThanEqualTo(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkLessThanEqualToParse() { final String EXPECTED_RESULT = "(1 <= 2)"; QLParser parser = ASTBuilder.getQlParser("1<=2"); LessThanEqualTo expression = (LessThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLessThanEqualToNestedParse() { final String EXPECTED_RESULT = "((1 <= 2) <= 3)"; QLParser parser = ASTBuilder.getQlParser("1<=2<=3"); LessThanEqualTo expression = (LessThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
LessThan extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " < " + getRight() + ")"; } LessThan(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkLessThanParse() { final String EXPECTED_RESULT = "(1 < 2)"; QLParser parser = ASTBuilder.getQlParser("1<2"); LessThan expression = (LessThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLessThanNestedParse() { final String EXPECTED_RESULT = "((1 < 2) < 3)"; QLParser parser = ASTBuilder.getQlParser("1<2<3"); LessThan expression = (LessThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
Subtraction extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " - " + getRight() + ")"; } Subtraction(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkSubtractionParse() { final String EXPECTED_RESULT = "(1 - 2)"; QLParser parser = ASTBuilder.getQlParser("1-2"); Subtraction expression = (Subtraction) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkSubtractionNestedParse() { final String EXPECTED_RESULT = "((1 - 2) - 3)"; QLParser parser = ASTBuilder.getQlParser("1-2-3"); Subtraction expression = (Subtraction) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
DependencyChecker { public DependencyChecker() { this.dependencies = new HashSet<>(); } DependencyChecker(); ErrorLogger checkForCircularDependencies(Map<String, List<Parameter>> expressionMap); }
|
@Test public void testDependencyChecker() { DependencyChecker checker = new DependencyChecker(); int EXPECTED_PAIRS = 6; int EXPECTED_REFLEXIVE_PAIRS = 3; DependencyPair pair1 = new DependencyPair("test1", "test2"); DependencyPair pair2 = new DependencyPair("test2", "test3"); DependencyPair pair3 = new DependencyPair("test3", "test1"); Set<DependencyPair> dependencySet = new HashSet<DependencyPair>() {{ add(pair1); add(pair2); add(pair3); }}; Set<DependencyPair> closure = checker.makeClosure(dependencySet); int reflexiveCount = 0; for (DependencyPair pair : closure) { if (pair.isReflexive()) { reflexiveCount++; } } assertEquals(EXPECTED_PAIRS, closure.size()); assertEquals(EXPECTED_REFLEXIVE_PAIRS, reflexiveCount); }
|
Division extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " / " + getRight() + ")"; } Division(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkDivisionParse() { final String EXPECTED_RESULT = "(1 / 2)"; QLParser parser = ASTBuilder.getQlParser("1/2"); Division expression = (Division) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkDivisionNestedParse() { final String EXPECTED_RESULT = "((1 / 2) / 3)"; QLParser parser = ASTBuilder.getQlParser("1/2/3"); Division expression = (Division) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
LogicalAnd extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " && " + getRight() + ")"; } LogicalAnd(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkLogicalAndParse() { final String EXPECTED_RESULT = "(1 && 2)"; QLParser parser = ASTBuilder.getQlParser("1&&2"); LogicalAnd expression = (LogicalAnd) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLogicalAndNestedParse() { final String EXPECTED_RESULT = "((1 && 2) && 3)"; QLParser parser = ASTBuilder.getQlParser("1&&2&&3"); LogicalAnd expression = (LogicalAnd) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
GreaterThan extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " > " + getRight() + ")"; } GreaterThan(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkGreaterThanParse() { final String EXPECTED_RESULT = "(1 > 2)"; QLParser parser = ASTBuilder.getQlParser("1>2"); GreaterThan expression = (GreaterThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkGreaterThanNestedParse() { final String EXPECTED_RESULT = "((1 > 2) > 3)"; QLParser parser = ASTBuilder.getQlParser("1>2>3"); GreaterThan expression = (GreaterThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
NotEqual extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " != " + getRight() + ")"; } NotEqual(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkNotEqualParse() { final String EXPECTED_RESULT = "(1 != 2)"; QLParser parser = ASTBuilder.getQlParser("1!=2"); NotEqual expression = (NotEqual) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkNotEqualNestedParse() { final String EXPECTED_RESULT = "((1 != 2) != 3)"; QLParser parser = ASTBuilder.getQlParser("1!=2!=3"); NotEqual expression = (NotEqual) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
Equal extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " == " + getRight() + ")"; } Equal(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkEqualParse() { final String EXPECTED_RESULT = "(1 == 2)"; QLParser parser = ASTBuilder.getQlParser("1==2"); Equal expression = (Equal) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkEqualNestedParse() { final String EXPECTED_RESULT = "((1 == 2) == 3)"; QLParser parser = ASTBuilder.getQlParser("1==2==3"); Equal expression = (Equal) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
ExpressionChecker implements StatementVisitor<Void, String>, ExpressionVisitor<Void, String> { public ErrorLogger checkExpressions(Form form, TypeTable typeTable) { this.typeTable = typeTable; this.logger = new ErrorLogger(); this.expressionMap = new HashMap<>(); for (Statement statement : form.getStatements()) { statement.accept(this, null); } checkForMissingParameters(typeTable); return logger; } ErrorLogger checkExpressions(Form form, TypeTable typeTable); Map<String, List<Parameter>> getExpressionMap(); @Override Void visit(CalculatedQuestion calculatedQuestion, String context); @Override Void visit(Question question, String context); @Override Void visit(IfStatement ifStatement, String context); @Override Void visit(IfElseStatement ifElseStatement, String context); @Override Void visit(ParameterGroup parameterGroup, String context); @Override Void visit(StringLiteral stringLiteral, String context); @Override Void visit(IntegerLiteral integerLiteral, String context); @Override Void visit(BooleanLiteral booleanLiteral, String context); @Override Void visit(Addition addition, String context); @Override Void visit(Subtraction subtraction, String context); @Override Void visit(Multiplication multiplication, String context); @Override Void visit(Division division, String context); @Override Void visit(NotEqual notEqual, String context); @Override Void visit(Equal equal, String context); @Override Void visit(GreaterThan greaterThan, String context); @Override Void visit(GreaterThanEqualTo greaterThanEqualTo, String context); @Override Void visit(LessThan lessThan, String context); @Override Void visit(LessThanEqualTo lessThanEqualTo, String context); @Override Void visit(LogicalAnd logicalAnd, String context); @Override Void visit(LogicalOr logicalOr, String context); @Override Void visit(Negation negation, String context); @Override Void visit(Parameter parameter, String context); }
|
@Test public void checkExpressions() { int EXPECTED_ERRORS = 1; ExpressionChecker checker = new ExpressionChecker(); ASTBuilder parser = new ASTBuilder(); Form form = parser.getForm(parser.getQlParser("form test { if (parameter1) { \"Test\" testquestion:boolean; } if (testquestion2) { \"anothertest\" anothertest:boolean; } }")); TypeTable typeTable = new TypeTable(); typeTable.addEntry("testquestion2", new BooleanType()); ErrorLogger logger = checker.checkExpressions(form, typeTable); assertEquals(EXPECTED_ERRORS, logger.getErrorNumber()); }
|
Question extends Item { public ValueType getType() { return type; } Question(int lineNumber, String label, String identifier, ValueType type); String getLabel(); String getIdentifier(); ValueType getType(); @Override String toString(); @Override T accept(ItemVisitor<T> visitor); }
|
@Test public void testIntegerValueType() throws IOException { String qlForm = "form taxOfficeExample { \"q1?\" value: integer }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question question = (Question) questions.get(0); assertThat(question.getType(), instanceOf(Integer.class)); }
@Test public void testMoneyValueType() throws IOException { String qlForm = "form taxOfficeExample { \"q1?\" value: money }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question question = (Question) questions.get(0); assertThat(question.getType(), instanceOf(Money.class)); }
|
ComputedQuestion extends Question { public Expression getComputedValue() { return computedValue; } ComputedQuestion(int lineNumber, String question, String value, ValueType type, Expression computedValue); Expression getComputedValue(); @Override T accept(ItemVisitor<T> visitor); }
|
@Test public void testGroupedExpression() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: money = (5 - 1) }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(Money.class)); assertThat(question.getComputedValue(), instanceOf(GroupedExpression.class)); }
@Test public void testBooleanExpression() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: boolean = true == true }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(Boolean.class)); assertThat(question.getComputedValue(), instanceOf(BinaryExpression.class)); }
@Test public void testComputationExpression() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: integer = 1+1 }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(Integer.class)); assertThat(question.getComputedValue(), instanceOf(Addition.class)); }
@Test public void testBooleanLiteral() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: boolean = true }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(Boolean.class)); assertThat(question.getComputedValue(), instanceOf(BooleanLiteral.class)); }
@Test public void testStringLiteral() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: string = \"string\" }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(String.class)); assertThat(question.getComputedValue(), instanceOf(StringerLiteral.class)); }
@Test public void testIntegerLiteral() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: integer = 1 }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(Integer.class)); assertThat(question.getComputedValue(), instanceOf(IntegerLiteral.class)); }
@Test public void testIdentifier() throws IOException { java.lang.String qlForm = "form taxOfficeExample { \"q1?\" value: string = var }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); ComputedQuestion question = (ComputedQuestion) questions.get(0); assertThat(question.getType(), instanceOf(String.class)); assertThat(question.getComputedValue(), instanceOf(Identifier.class)); }
|
IfThenElse extends IfThen { public List<Item> getElseStatements() { return elseStatements; } IfThenElse(int lineNumber, Expression condition, List<Item> thenStatements, List<Item> elseStatements); List<Item> getElseStatements(); @Override T accept(ItemVisitor<T> visitor); }
|
@Test public void testIfElseBlock() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } else { \"q2?\" val2: boolean } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThenElse ifThenElse = (IfThenElse) questions.get(0); assertEquals(1, ifThenElse.getThenStatements().size()); assertEquals(1, ifThenElse.getElseStatements().size()); }
@Test public void testEmptyElseStatements() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } else { } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThenElse ifThenElse = (IfThenElse) questions.get(0); assertEquals(1, ifThenElse.getThenStatements().size()); assertEquals(0, ifThenElse.getElseStatements().size()); }
|
ExpressionEvaluator implements ExpressionVisitor<Value, String> { public Value evaluateExpression(String id, Expression expression, ValueTable valueTable) { this.valueTable = valueTable; try { return expression.accept(this, id); } catch (InvalidOperationException e) { LOGGER.severe("Invalid operation on " + e.value.getValue() + "!"); return new NullValue(); } } Value evaluateExpression(String id, Expression expression, ValueTable valueTable); @Override Value visit(Addition addition, String context); @Override Value visit(Division division, String context); @Override Value visit(Equal equal, String context); @Override Value visit(GreaterThan greaterThan, String context); @Override Value visit(GreaterThanEqualTo greaterThanEqualTo, String context); @Override Value visit(LessThan lessThan, String context); @Override Value visit(LessThanEqualTo lessThanEqualTo, String context); @Override Value visit(LogicalAnd logicalAnd, String context); @Override Value visit(LogicalOr logicalOr, String context); @Override Value visit(Multiplication multiplication, String context); @Override Value visit(NotEqual notEqual, String context); @Override Value visit(Subtraction subtraction, String context); @Override Value visit(Negation negation, String context); @Override Value visit(Parameter parameter, String context); @Override Value visit(ParameterGroup parameterGroup, String context); @Override Value visit(StringLiteral stringLiteral, String context); @Override Value visit(IntegerLiteral integerLiteral, String context); @Override Value visit(BooleanLiteral booleanLiteral, String context); }
|
@Test public void testEvaluation() { final int RESULT_1 = 24; final int RESULT_2 = 120; final boolean RESULT_3 = true; final boolean RESULT_4 = true; final boolean RESULT_5 = true; Expression test1 = new Addition(new IntegerLiteral("12", 0, 0), new IntegerLiteral("12", 0, 0), 0, 0); Expression test2 = new Multiplication(new IntegerLiteral("12", 0, 0), new IntegerLiteral("10", 0, 0), 0, 0); Expression test3 = new LogicalAnd(new BooleanLiteral("true", 0, 0), new BooleanLiteral("true", 0, 0), 0, 0); Expression test4 = new Equal(new StringLiteral("test", 0, 0), new StringLiteral("test", 0, 0), 0, 0); Expression test5 = new Equal(new IntegerLiteral("12", 0, 0), new IntegerLiteral("12", 0, 0), 0, 0); ValueTable values = new ValueTable(); ExpressionEvaluator eval = new ExpressionEvaluator(); values.addOrUpdateValue("test1", eval.evaluateExpression("test1", test1, values)); values.addOrUpdateValue("test2", eval.evaluateExpression("test2", test2, values)); values.addOrUpdateValue("test3", eval.evaluateExpression("test3", test3, values)); values.addOrUpdateValue("test4", eval.evaluateExpression("test4", test4, values)); values.addOrUpdateValue("test5", eval.evaluateExpression("test5", test5, values)); assertNotNull(values.getValueByID("test1")); assertNotNull(values.getValueByID("test2")); assertNotNull(values.getValueByID("test3")); assertNotNull(values.getValueByID("test4")); assertNotNull(values.getValueByID("test5")); assertEquals(RESULT_1, values.getValueByID("test1").getValue()); assertEquals(RESULT_2, values.getValueByID("test2").getValue()); assertEquals(RESULT_3, values.getValueByID("test3").getValue()); assertEquals(RESULT_4, values.getValueByID("test4").getValue()); assertEquals(RESULT_5, values.getValueByID("test5").getValue()); }
|
IfThen extends Item { public List<Item> getThenStatements() { return thenStatements; } IfThen(int lineNumber, Expression condition, List<Item> thenStatements); Expression getCondition(); List<Item> getThenStatements(); @Override T accept(ItemVisitor<T> visitor); }
|
@Test public void testIfBlock() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThen ifThen = (IfThen) questions.get(0); assertEquals("taxOfficeExample", form.getFormId()); assertEquals(1, ifThen.getThenStatements().size()); }
@Test public void testEmptyThenStatements() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThen ifThen = (IfThen) questions.get(0); assertEquals(0, ifThen.getThenStatements().size()); }
@Test public void testNestedIfBlock() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { if (bool) { \"q2?\" val2: boolean } } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThen c1 = (IfThen) questions.get(0); assertEquals(1, questions.size()); assertEquals(1, c1.getThenStatements().size()); assertThat(c1.getThenStatements().get(0), instanceOf(IfThen.class)); }
@Test public void testMultipleIfBlocks() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } if (bool) { \"q2?\" val2: boolean } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThen c1 = (IfThen) questions.get(0); IfThen c2 = (IfThen) questions.get(0); assertEquals(2, questions.size()); assertEquals(1, c1.getThenStatements().size()); assertEquals(1, c2.getThenStatements().size()); }
|
Evaluator implements ExpressionVisitor<Value> { @Override public Value visit(GroupedExpression node) { return node.getExpression().accept(this); } Evaluator(Environment environmentsTable); @Override Value visit(GroupedExpression node); @Override Value visit(Identifier identifier); @Override Value visit(StringerLiteral stringerLiteral); @Override Value visit(IntegerLiteral integerLiteral); @Override Value visit(BooleanLiteral booleanLiteral); @Override Value visit(Expression expression); @Override Value visit(Addition addition); @Override Value visit(Division division); @Override Value visit(Equal equal); @Override Value visit(GreaterThan greaterThan); @Override Value visit(GreaterThanOrEqual greaterThanOrEqual); @Override Value visit(LessThan lessThan); @Override Value visit(LessThanOrEqual lessThanOrEqual); @Override Value visit(LogicalAnd logicalAnd); @Override Value visit(LogicalOr logicalOr); @Override Value visit(Multiplication multiplication); @Override Value visit(NotEqual notEqual); @Override Value visit(Subtraction subtraction); }
|
@Test public void testStringLiteral() throws Exception { StringerLiteral stringerLiteral = new StringerLiteral(1, "ql"); StringValue stringValue = (StringValue) evaluator.visit(stringerLiteral); assertEquals(stringerLiteral.getValue(), stringValue.getValue()); }
@Test public void testIntegerLiteral() throws Exception { IntegerLiteral integerLiteral = new IntegerLiteral(1, 1); IntegerValue integerValue = (IntegerValue) evaluator.visit(integerLiteral); assertEquals(integerLiteral.getValue(), (int) integerValue.getValue()); }
@Test public void testBooleanLiteral() throws Exception { BooleanLiteral booleanLiteral = new BooleanLiteral(1, true); BooleanValue booleanValue = (BooleanValue) evaluator.visit(booleanLiteral); assertEquals(booleanLiteral.isValue(), booleanValue.getValue()); }
@Test public void testAdditionIntegerLiteral() throws Exception { Addition addition = new Addition(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); IntegerValue value = (IntegerValue) evaluator.visit(addition); assertEquals(new Integer(8), value.getValue()); }
@Test public void testAdditionStringLiteral() throws Exception { Addition addition = new Addition(1, new StringerLiteral(1, "q"), new StringerLiteral(1, "l")); StringValue value = (StringValue) evaluator.visit(addition); assertEquals("ql", value.getValue()); }
@Test public void testAdditionStringLiteralEmptyString() throws Exception { Addition addition = new Addition(1, new StringerLiteral(1, ""), new StringerLiteral(1, "")); StringValue value = (StringValue) evaluator.visit(addition); assertEquals("", value.getValue()); }
@Test public void testDivision() throws Exception { Division division = new Division(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); IntegerValue value = (IntegerValue) evaluator.visit(division); assertEquals(new Integer(3), value.getValue()); }
@Test public void testEqualBooleanLiteralTrue() throws Exception { Equal equal = new Equal(1, new BooleanLiteral(1, true), new BooleanLiteral(1, true)); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(true, value.getValue()); }
@Test public void testEqualBooleanLiteralFalse() throws Exception { Equal equal = new Equal(1, new BooleanLiteral(1, true), new BooleanLiteral(1, false)); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(false, value.getValue()); }
@Test public void testEqualIntegerLiteralTrue() throws Exception { Equal equal = new Equal(1, new IntegerLiteral(1, 1), new IntegerLiteral(1, 1)); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(true, value.getValue()); }
@Test public void testEqualIntegerLiteralFalse() throws Exception { Equal equal = new Equal(1, new IntegerLiteral(1, 1), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(false, value.getValue()); }
@Test public void testEqualStringLiteralTrue() throws Exception { Equal equal = new Equal(1, new StringerLiteral(1, "a"), new StringerLiteral(1, "a")); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(true, value.getValue()); }
@Test public void testEqualStringLiteralFalse() throws Exception { Equal equal = new Equal(1, new StringerLiteral(1, "a"), new StringerLiteral(1, "b")); BooleanValue value = (BooleanValue) evaluator.visit(equal); assertEquals(false, value.getValue()); }
@Test public void testGreaterThanTrue() throws Exception { GreaterThan lessThan = new GreaterThan(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testGreaterThanFalse() throws Exception { GreaterThan lessThan = new GreaterThan(1, new IntegerLiteral(1, 2), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(false, value.getValue()); }
@Test public void testGreaterThanOrEqualTrue() throws Exception { GreaterThanOrEqual lessThan = new GreaterThanOrEqual(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testGreaterThanOrEqualTrueBothEqual() throws Exception { GreaterThanOrEqual lessThan = new GreaterThanOrEqual(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testGreaterThanOrEqualFalse() throws Exception { GreaterThanOrEqual lessThan = new GreaterThanOrEqual(1, new IntegerLiteral(1, 2), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(false, value.getValue()); }
@Test public void testLessThanTrue() throws Exception { LessThan lessThan = new LessThan(1, new IntegerLiteral(1, 2), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testLessThanFalse() throws Exception { LessThan lessThan = new LessThan(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(false, value.getValue()); }
@Test public void testLessThanOrEqualTrue() throws Exception { LessThanOrEqual lessThan = new LessThanOrEqual(1, new IntegerLiteral(1, 2), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testLessThanOrEqualTrueBothEqual() throws Exception { LessThanOrEqual lessThan = new LessThanOrEqual(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 6)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(true, value.getValue()); }
@Test public void testLessThanOrEqualFalse() throws Exception { LessThanOrEqual lessThan = new LessThanOrEqual(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(lessThan); assertEquals(false, value.getValue()); }
@Test public void testLogicalAndBooleanLiteralTrue() throws Exception { LogicalAnd logicalAnd = new LogicalAnd(1, new BooleanLiteral(1, true), new BooleanLiteral(1, true)); BooleanValue value = (BooleanValue) evaluator.visit(logicalAnd); assertEquals(true, value.getValue()); }
@Test public void testLogicalAndBooleanLiteralFalse() throws Exception { LogicalAnd logicalAnd = new LogicalAnd(1, new BooleanLiteral(1, true), new BooleanLiteral(1, false)); BooleanValue value = (BooleanValue) evaluator.visit(logicalAnd); assertEquals(false, value.getValue()); }
@Test public void testLogicalOrBooleanLiteralTrue() throws Exception { LogicalOr logicalOr = new LogicalOr(1, new BooleanLiteral(1, true), new BooleanLiteral(1, true)); BooleanValue value = (BooleanValue) evaluator.visit(logicalOr); assertEquals(true, value.getValue()); }
@Test public void testLogicalOrBooleanLiteralFalse() throws Exception { LogicalOr logicalOr = new LogicalOr(1, new BooleanLiteral(1, false), new BooleanLiteral(1, false)); BooleanValue value = (BooleanValue) evaluator.visit(logicalOr); assertEquals(false, value.getValue()); }
@Test public void testLogicalOrBooleanLiteralLeftTrue() throws Exception { LogicalOr logicalOr = new LogicalOr(1, new BooleanLiteral(1, true), new BooleanLiteral(1, false)); BooleanValue value = (BooleanValue) evaluator.visit(logicalOr); assertEquals(true, value.getValue()); }
@Test public void testLogicalOrBooleanLiteralRightTrue() throws Exception { LogicalOr logicalOr = new LogicalOr(1, new BooleanLiteral(1, false), new BooleanLiteral(1, true)); BooleanValue value = (BooleanValue) evaluator.visit(logicalOr); assertEquals(true, value.getValue()); }
@Test public void testMultiplication() throws Exception { Multiplication multiplication = new Multiplication(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); IntegerValue value = (IntegerValue) evaluator.visit(multiplication); assertEquals(new Integer(12), value.getValue()); }
@Test public void testNotEqualBooleanLiteralTrue() throws Exception { NotEqual notEqual = new NotEqual(1, new BooleanLiteral(1, true), new BooleanLiteral(1, false)); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(true, value.getValue()); }
@Test public void testNotEqualBooleanLiteralFalse() throws Exception { NotEqual notEqual = new NotEqual(1, new BooleanLiteral(1, true), new BooleanLiteral(1, true)); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(false, value.getValue()); }
@Test public void testNotEqualIntegerLiteralTrue() throws Exception { NotEqual notEqual = new NotEqual(1, new IntegerLiteral(1, 1), new IntegerLiteral(1, 2)); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(true, value.getValue()); }
@Test public void testNotEqualIntegerLiteralFalse() throws Exception { NotEqual notEqual = new NotEqual(1, new IntegerLiteral(1, 1), new IntegerLiteral(1, 1)); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(false, value.getValue()); }
@Test public void testNotEqualStringLiteralTrue() throws Exception { NotEqual notEqual = new NotEqual(1, new StringerLiteral(1, "a"), new StringerLiteral(1, "b")); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(true, value.getValue()); }
@Test public void testNotEqualStringLiteralFalse() throws Exception { NotEqual notEqual = new NotEqual(1, new StringerLiteral(1, "a"), new StringerLiteral(1, "a")); BooleanValue value = (BooleanValue) evaluator.visit(notEqual); assertEquals(false, value.getValue()); }
@Test public void testSubtraction() throws Exception { Subtraction subtraction = new Subtraction(1, new IntegerLiteral(1, 6), new IntegerLiteral(1, 2)); IntegerValue value = (IntegerValue) evaluator.visit(subtraction); assertEquals(new Integer(4), value.getValue()); }
|
FileReader { public String readFile(File selectedFile) { String fileContents = ""; try (BufferedReader br = new BufferedReader(new java.io.FileReader(selectedFile))) { String line; while ((line = br.readLine()) != null) { fileContents = fileContents.concat(line + '\n'); } } catch (IOException e) { Logger.getAnonymousLogger().log(Level.SEVERE, "Exception", e); ErrorDialogGenerator.generateErrorListBox(e.getMessage(), "File Read Error", "There was an error reading the input file"); Platform.exit(); } return fileContents; } String readFile(File selectedFile); }
|
@Test public void readFile() { String output = fileReader.readFile(file); int expectedLines = 47; String[] lines = output.split(System.getProperty("line.separator")); assertEquals(expectedLines, lines.length); }
|
Parameter extends Expression { public String getID() { return this.id; } Parameter(String s, int line, int column); String getID(); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkParameterParse() { final String EXPECTED_RESULT = "testParameter"; QLParser parser = ASTBuilder.getQlParser("testParameter"); Parameter parameter = (Parameter) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, parameter.getID()); }
|
Multiplication extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " * " + getRight() + ")"; } Multiplication(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkMultiplicationParse() { final String EXPECTED_RESULT = "(1 * 2)"; QLParser parser = ASTBuilder.getQlParser("1*2"); Multiplication expression = (Multiplication) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkMultiplicationNestedParse() { final String EXPECTED_RESULT = "((1 * 2) * 3)"; QLParser parser = ASTBuilder.getQlParser("1*2*3"); Multiplication expression = (Multiplication) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
GreaterThanEqualTo extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " >= " + getRight() + ")"; } GreaterThanEqualTo(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }
|
@Test public void checkGreaterThenEqualToParse() { final String EXPECTED_RESULT = "(1 >= 2)"; QLParser parser = ASTBuilder.getQlParser("1>=2"); GreaterThanEqualTo expression = (GreaterThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkGreaterThenEqualToNestedParse() { final String EXPECTED_RESULT = "((1 >= 2) >= 3)"; QLParser parser = ASTBuilder.getQlParser("1>=2>=3"); GreaterThanEqualTo expression = (GreaterThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
FactMap implements NameValueReferableMap<T> { @Override public boolean isEmpty() { return _facts.isEmpty(); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }
|
@Test public void isEmptyShouldDelegateToMap() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); Mockito.when(map.isEmpty()).thenReturn(true); Assert.assertTrue(factMap.isEmpty()); Mockito.verify(map, Mockito.times(1)).isEmpty(); }
|
AnnotationUtils { public static Optional<Field> getAnnotatedField(Class annotation, Class clazz) { List<Field> fields = getAnnotatedFields(annotation, clazz); return Optional.ofNullable(fields.size() > 0 ? fields.get(0) : null); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }
|
@Test public void getAnnotatedFieldShouldFindFirstAnnotatedField() { Optional<Field> givenField = getAnnotatedField(Given.class, SampleRuleWithResult.class); Assert.assertEquals(givenField.get().getType(), Fact.class); Assert.assertEquals(givenField.get().getName(), "_fact1"); }
@Test public void getAnnotatedFieldShouldFindFirsAnnotatedFieldInCurrentClassBeforeParent() { Optional<Field> givenField = getAnnotatedField(Given.class, SubRuleWithResult.class); Assert.assertEquals(givenField.get().getType(), String.class); Assert.assertEquals(givenField.get().getName(), "_subFact"); }
|
AnnotationUtils { @SuppressWarnings("unchecked") public static List<Method> getAnnotatedMethods(Class annotation, Class clazz) { List<Method> methods = new ArrayList<>(); if (clazz == Object.class) { return methods; } methods.addAll((List<Method>) Arrays.stream(clazz.getDeclaredMethods()) .filter(field -> field.getAnnotation(annotation) != null) .collect(Collectors.toList())); methods.addAll(getAnnotatedMethods(annotation, clazz.getSuperclass())); return methods; } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }
|
@Test public void getAnnotatedMethodsShouldFindAnnotatedMethods() { List<Method> thenMethods = getAnnotatedMethods(Then.class, SampleRuleWithResult.class); List<Method> whenMethods = getAnnotatedMethods(When.class, SampleRuleWithResult.class); Assert.assertEquals(1, thenMethods.size()); Assert.assertEquals(1, whenMethods.size()); }
@Test public void getAnnotatedMethodsShouldFindAnnotatedMethodsInParent() { List<Method> thenMethods = getAnnotatedMethods(Then.class, SubRuleWithResult.class); List<Method> whenMethods = getAnnotatedMethods(When.class, SubRuleWithResult.class); Assert.assertEquals(1, thenMethods.size()); Assert.assertEquals(2, whenMethods.size()); }
|
AnnotationUtils { public static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz) { List<Method> methods = getAnnotatedMethods(annotation, clazz); return Optional.ofNullable(methods.size() > 0 ? methods.get(0) : null); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }
|
@Test public void getAnnotatedMethodShouldFindFirstMethod() { Optional<Method> whenMethod = getAnnotatedMethod(When.class, SubRuleWithResult.class); Assert.assertEquals(whenMethod.get().getName(), "condition"); }
@Test public void getAnnotatedMethodShouldReturnEmptyOptionalWhenAnnotationNotFound() { Optional<Method> whenMethod = getAnnotatedMethod(When.class, SampleRuleWithoutRuleAnnotation.class); Assert.assertFalse(whenMethod.isPresent()); }
|
AnnotationUtils { @SuppressWarnings("unchecked") public static <A extends Annotation> A getAnnotation(Class<A> annotation, Class<?> clazz) { return Optional.ofNullable(clazz.getAnnotation(annotation)).orElse((A) Arrays.stream(clazz.getDeclaredAnnotations()) .flatMap(anno -> Arrays.stream(anno.getClass().getInterfaces()) .flatMap(iface -> Arrays.stream(iface.getDeclaredAnnotations()))) .filter(annotation::isInstance) .findFirst().orElse(null) ); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }
|
@Test public void getAnnotationShouldFindTheAnnotationOfAnAnnotation() { Rule ruleAnnotation = getAnnotation(Rule.class, SubRuleWithResult.class); SubRuleAnnotation subRuleAnnotation = getAnnotation(SubRuleAnnotation.class, SubRuleWithResult.class); Assert.assertNotNull(ruleAnnotation); Assert.assertNotNull(subRuleAnnotation); }
|
ArrayUtils { @SuppressWarnings("unchecked") public static <T> T[] combine(T[] array1, T[] array2) { return combine(array1, array2, array1.length + array2.length); } private ArrayUtils(); @SuppressWarnings("unchecked") static T[] combine(T[] array1, T[] array2); @SuppressWarnings("unchecked") static T[] combine(T[] array1, T[] array2, int maxElements); }
|
@Test public void combineMethodShouldCombineTwoArrays() { String[] array1 = {"one", "two", "three"}; String[] array2 = {"four", "five", "six"}; String[] combinedArray = combine(array1, array2); for (int i = 0; i < array1.length; i++) { Assert.assertEquals(array1[i], combinedArray[i]); } for (int i = 0; i < combinedArray.length - array1.length; i++) { Assert.assertEquals(array2[i], combinedArray[i + array1.length]); } Assert.assertEquals(array1.length + array2.length, combinedArray.length); }
@Test public void combineMethodShouldCombineTwoArraysUpToMaxSizeWhenMaxSizeLessThanArray1Elements() { String[] array1 = {"one", "two", "three"}; String[] array2 = {"four", "five", "six"}; String[] combinedArray = combine(array1, array2, 2); for (int i = 0; i < combinedArray.length; i++) { Assert.assertEquals(array1[i], combinedArray[i]); } Assert.assertEquals(2, combinedArray.length); }
@Test public void combineMethodShouldCombineTwoArraysUpToMaxSizeWhenMaxSizeGreaterThanArray1Elements() { String[] array1 = {"one", "two", "three"}; String[] array2 = {"four", "five", "six"}; String[] combinedArray = combine(array1, array2, 5); for (int i = 0; i < array1.length; i++) { Assert.assertEquals(array1[i], combinedArray[i]); } for (int i = 0; i < combinedArray.length - array1.length; i++) { Assert.assertEquals(array2[i], combinedArray[i + array1.length]); } Assert.assertEquals(5, combinedArray.length); }
@Test public void combineMethodShouldCombineTwoArraysUpToMaxSizeWhenMaxSizeGreaterThanArrayAllElements() { String[] array1 = {"one", "two", "three"}; String[] array2 = {"four", "five", "six"}; String[] combinedArray = combine(array1, array2, 10); for (int i = 0; i < array1.length; i++) { Assert.assertEquals(array1[i], combinedArray[i]); } for (int i = 0; i < combinedArray.length - array1.length; i++) { Assert.assertEquals(array2[i], combinedArray[i + array1.length]); } Assert.assertEquals(array1.length + array2.length, combinedArray.length); }
|
FactMap implements NameValueReferableMap<T> { @Override public boolean containsValue(Object value) { return _facts.containsValue(value); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }
|
@Test public void containsValueShouldDelegateToMap() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); Mockito.when(map.containsValue("value1")).thenReturn(true); Mockito.when(map.containsValue("value2")).thenReturn(false); Assert.assertTrue(factMap.containsValue("value1")); Assert.assertFalse(factMap.containsValue("value2")); Mockito.verify(map, Mockito.times(1)).containsValue("value1"); Mockito.verify(map, Mockito.times(1)).containsValue("value2"); }
|
DecisionBook extends RuleBook<T> { public void addRule(Decision<T, U> rule) { if (rule == null) { return; } super.addRule(rule); rule.setResult(_result); } final DecisionBook<T, U> withDefaultResult(U result); void addRule(Decision<T, U> rule); U getResult(); }
|
@Test @SuppressWarnings("unchecked") public void decisionBooksRunDecisions() { Decision<String, Boolean> decision1 = (Decision<String, Boolean>) mock(Decision.class); Decision<String, Boolean> decision2 = (Decision<String, Boolean>) mock(Decision.class); Fact<String> fact = new Fact<String>("hello", "Hello"); DecisionBook<String, Boolean> decisionBook = spy(new DecisionBook<String, Boolean>() { @Override protected void defineRules() { } }); decisionBook.given(fact).addRule(decision1); decisionBook.addRule(decision2); decisionBook.run(); verify(decision1, times(1)).setNextRule(decision2); verify(decision1, times(1)).run(); verify(decisionBook, times(0)).defineRules(); verify(decision1, times(1)).given(anyList()); }
@Test @SuppressWarnings("unchecked") public void decisionBooksShouldRunDecisionsAndRules() { Decision<String, Boolean> decision1 = (Decision<String, Boolean>) mock(Decision.class); Rule<String> rule = (Rule<String>) mock(Rule.class); Decision<String, Boolean> decision2 = (Decision<String, Boolean>) spy(Decision.class); DecisionBook<String, Boolean> decisionBook = spy(new DecisionBook<String, Boolean>() { @Override protected void defineRules() { } }); decisionBook.given("hello", "world").addRule(decision1); decisionBook.addRule(rule); decisionBook.addRule(decision2); decisionBook.run(); verify(decision1, times(1)).setNextRule(rule); verify(rule, times(1)).setNextRule(decision2); verify(decision1, times(1)).run(); verify(decision1, times(1)).given(anyList()); verify(decisionBook, times(0)).defineRules(); }
@Test public void decisionBooksShouldNotErrorOnNullRule() { DecisionBook decisionBook = new DecisionBook() { @Override protected void defineRules() { } }; decisionBook.addRule(null); }
|
RuleAdapter implements Rule { @Override public void addFacts(NameValueReferable... facts) { _rule.addFacts(facts); mapFactsToProperties(_rule.getFacts()); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }
|
@Test public void givenAttributesShouldMapToInheritedFactsParams() throws InvalidClassException { SubRuleWithResult subRuleWithResult = new SubRuleWithResult(); RuleAdapter ruleAdapter = new RuleAdapter(subRuleWithResult); ruleAdapter.addFacts(_factMap); Assert.assertEquals("FirstFact", subRuleWithResult.getFact1()); Assert.assertEquals("SecondFact", subRuleWithResult.getFact2()); Assert.assertEquals(2, subRuleWithResult.getStrList().size()); Assert.assertEquals(2, subRuleWithResult.getStrSet().size()); Assert.assertEquals(2, subRuleWithResult.getStrMap().size()); Assert.assertEquals(_factMap.size(), subRuleWithResult.getFactMap().size()); for (Map.Entry kvpair : _factMap.entrySet()) { Assert.assertEquals(((Fact)kvpair.getValue()).getValue(), subRuleWithResult.getFactMap().getValue((String)kvpair.getKey())); } Assert.assertEquals(1, subRuleWithResult.getValue1()); Assert.assertEquals(1, subRuleWithResult.getValueSet().size()); Assert.assertEquals(1, subRuleWithResult.getValueList().size()); Assert.assertEquals(1, subRuleWithResult.getValueMap().size()); }
|
RuleAdapter implements Rule { @Override @SuppressWarnings("unchecked") public Predicate<NameValueReferableMap> getCondition() { if (_rule.getCondition() != null) { return _rule.getCondition(); } _rule.setCondition(Arrays.stream(_pojoRule.getClass().getMethods()) .filter(method -> method.getReturnType() == boolean.class || method.getReturnType() == Boolean.class) .filter(method -> Arrays.stream(method.getDeclaredAnnotations()).anyMatch(When.class::isInstance)) .findFirst() .<Predicate>map(method -> object -> { try { return (Boolean) method.invoke(_pojoRule); } catch (InvocationTargetException | IllegalAccessException ex) { if (_actionType == RuleChainActionType.ERROR_ON_FAILURE) { throw new RuleException(ex.getCause() == null ? ex : ex.getCause()); } if (_actionType == RuleChainActionType.STOP_ON_FAILURE) { _rule.setRuleState(RuleState.EXCEPTION); } LOGGER.error( "Unable to validate condition due to an exception. It will be evaluated as false", ex); return false; } }) .orElse(o -> true)); return _rule.getCondition(); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }
|
@Test public void pojoWithNoWhenAnnotationDefaultsToFalse() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Predicate predicate = ruleAdapter.getCondition(); Assert.assertTrue(predicate.test(null)); }
|
RuleAdapter implements Rule { @Override @SuppressWarnings("unchecked") public List<Object> getActions() { if (_rule.getActions().size() < 1) { List<Object> actionList = new ArrayList<>(); for (Method actionMethod : getAnnotatedMethods(Then.class, _pojoRule.getClass())) { actionMethod.setAccessible(true); Object then = getThenMethodAsBiConsumer(actionMethod).map(Object.class::cast) .orElse(getThenMethodAsConsumer(actionMethod).orElse(factMap -> { })); actionList.add(then); } _rule.getActions().addAll(actionList); } return _rule.getActions(); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }
|
@Test public void pojoWithNoThenAnnotationDefaultsToNext() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Assert.assertEquals(0, ((List<Object>)ruleAdapter.getActions()).size()); }
|
RuleAdapter implements Rule { @Override public void addFactNameFilter(String... factNames) { throw new UnsupportedOperationException(); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }
|
@Test(expected = UnsupportedOperationException.class) public void usingMethodShouldThrowNotImplemented() throws InvalidClassException { RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult()); ruleAdapter.addFactNameFilter(); }
|
RuleAdapter implements Rule { @Override @SuppressWarnings("unchecked") public void addAction(Consumer action) { _rule.addAction(action); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }
|
@Test public void thenMethodShouldDelegateToRuleThenMethod() throws InvalidClassException { Rule rule = mock(Rule.class); BiConsumer<NameValueReferable, Result> biConsumer = (result, facts) -> { }; RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); ruleAdapter.addAction(biConsumer); verify(rule, times(1)).addAction(biConsumer); }
|
AuditableRule implements Rule<T, U>, Auditable { @Override public String getName() { return _name; } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }
|
@Test @SuppressWarnings("unchecked") public void auditableRulesSetRuleNames() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule, "My Special Rule"); Assert.assertEquals("My Special Rule", auditable.getName()); }
@Test @SuppressWarnings("unchecked") public void auditableRulesGetClassNameAsDefaultName() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule); Assert.assertEquals("AuditableRule", auditable.getName()); }
|
FactMap implements NameValueReferableMap<T> { @Override public Fact<T> remove(Object key) { NameValueReferable<T> obj = _facts.remove(key); if (obj == null) { return null; } if (obj instanceof Fact) { return (Fact<T>)obj; } return new Fact<>(obj); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }
|
@Test public void removeShouldDelegateToMapAndReturnFact() { Map<String, Object> map = Mockito.mock(Map.class); NameValueReferable fact = new Fact("key", "value"); FactMap factMap = new FactMap(map); Mockito.when(map.remove("key")).thenReturn(fact); Assert.assertEquals(factMap.remove("key"), fact); Mockito.verify(map, Mockito.times(1)).remove("key"); }
@Test public void removeShouldDelegateToMapAndReturnNullIfMapReturnsNull() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); Mockito.when(map.remove("key")).thenReturn(null); Assert.assertNull(factMap.remove("key")); Mockito.verify(map, Mockito.times(1)).remove("key"); }
|
AuditableRule implements Rule<T, U>, Auditable { @Override public void setAuditor(Auditor auditor) { _auditor = auditor; _auditor.registerRule(this); } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }
|
@Test @SuppressWarnings("unchecked") public void auditableRulesRegisterThemselvesWithAuditors() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule); Auditor auditor = Mockito.mock(Auditor.class); auditable.setAuditor(auditor); Mockito.verify(auditor, Mockito.times(1)).registerRule(auditable); }
|
AuditableRule implements Rule<T, U>, Auditable { @Override public void addFacts(NameValueReferable... facts) { _rule.addFacts(facts); } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }
|
@Test @SuppressWarnings("unchecked") public void auditableRulesDelegateAddFactsToTheirRule() { Rule<String, String> rule = Mockito.mock(Rule.class); AuditableRule auditableRule = new AuditableRule<String, String>(rule); FactMap facts = Mockito.mock(FactMap.class); auditableRule.addFacts(facts); Mockito.verify(rule, Mockito.times(1)).addFacts(facts); }
@Test @SuppressWarnings("unchecked") public void auditableRulesDelegateAddFactsArrayToTheirRule() { Rule<String, String> rule = Mockito.mock(Rule.class); AuditableRule auditableRule = new AuditableRule<String, String>(rule); Fact[] facts = {new Fact("fact", "value")}; auditableRule.addFacts(facts); Mockito.verify(rule, Mockito.times(1)).addFacts(facts); }
|
AuditableRule implements Rule<T, U>, Auditable { @Override public void addFactNameFilter(String... factNames) { _rule.addFactNameFilter(factNames); } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }
|
@Test @SuppressWarnings("unchecked") public void auditableRulesDelegateFactNameFiltersTheirRule() { Rule<String, String> rule = Mockito.mock(Rule.class); AuditableRule auditableRule = new AuditableRule<String, String>(rule); String[] filters = {"filter"}; auditableRule.addFactNameFilter(filters); Mockito.verify(rule, Mockito.times(1)).addFactNameFilter(filters); }
|
TypeConvertibleFactMap implements NameValueReferableTypeConvertibleMap<T> { @Override public String toString() { return _map.toString(); } TypeConvertibleFactMap(NameValueReferableMap<T> map); @Override String getStrVal(String name); @Override T getOne(); @Override T getValue(String name); @Override Integer getIntVal(String name); @Override Double getDblVal(String name); @Override Boolean getBoolVal(String name); @Override BigDecimal getBigDeciVal(String name); @Override void setValue(String name, T obj); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override NameValueReferable<T> get(Object key); @Override NameValueReferable<T> put(NameValueReferable<T> ref); @Override NameValueReferable<T> put(String key, NameValueReferable<T> value); @Override NameValueReferable<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void toStringDelegatesToDecoratedMap() { NameValueReferableMap factMap = mock(NameValueReferableMap.class); when(factMap.toString()).thenReturn("delegated!"); NameValueReferableMap facts = new TypeConvertibleFactMap(factMap); Assert.assertEquals("delegated!", facts.toString()); }
|
TypeConvertibleFactMap implements NameValueReferableTypeConvertibleMap<T> { @Override public void putAll(Map<? extends String, ? extends NameValueReferable<T>> map) { _map.putAll(map); } TypeConvertibleFactMap(NameValueReferableMap<T> map); @Override String getStrVal(String name); @Override T getOne(); @Override T getValue(String name); @Override Integer getIntVal(String name); @Override Double getDblVal(String name); @Override Boolean getBoolVal(String name); @Override BigDecimal getBigDeciVal(String name); @Override void setValue(String name, T obj); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override NameValueReferable<T> get(Object key); @Override NameValueReferable<T> put(NameValueReferable<T> ref); @Override NameValueReferable<T> put(String key, NameValueReferable<T> value); @Override NameValueReferable<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void putAllDelegatesToDecoratedMap() { NameValueReferableMap factMap = mock(NameValueReferableMap.class); FactMap map = new FactMap(); NameValueReferableMap facts = new TypeConvertibleFactMap(factMap); facts.putAll(map); verify(factMap, times(1)).putAll(map); }
|
StandardDecision implements Decision<T, U> { public static <T, U> StandardDecision<T, U> create(Class<T> factType, Class<U> resultType) { return new StandardDecision<T, U>(factType, resultType); } StandardDecision(Class<T> factClazz, Class<U> resultClazz); static StandardDecision<T, U> create(Class<T> factType, Class<U> resultType); static StandardDecision<Object, Object> create(); @Override @SuppressWarnings("unchecked") void run(Object... args); @Override Decision<T, U> given(String name, T value); @Override Decision<T, U> given(Fact<T>... facts); @Override Decision<T, U> given(List<Fact<T>> facts); @Override Decision<T, U> given(FactMap<T> facts); @Override Decision<T, U> givenUnTyped(FactMap facts); @Override FactMap getFactMap(); @Override Decision<T, U> when(Predicate<FactMap<T>> test); @Override Decision<T, U> then(BiConsumer<FactMap<T>, Result<U>> action); @Override Decision<T, U> then(Consumer<FactMap<T>> action); @Override Decision<T, U> stop(); @Override @SuppressWarnings("unchecked") Decision<T, U> using(String... factNames); @Override void setNextRule(Rule<T> rule); @Override U getResult(); @Override void setResult(Result<U> result); @Override Predicate<FactMap<T>> getWhen(); @Override List<Object> getThen(); }
|
@Test @SuppressWarnings("checked") public void standardDecisionIsCreated() { Decision<String, Boolean> decision2 = StandardDecision.create(String.class, Boolean.class); Decision decision3 = StandardDecision.create(); Assert.assertNotNull(decision2); Assert.assertNotNull(decision3); }
|
RuleAdapter implements Decision { @Override @SuppressWarnings("unchecked") public Decision given(Fact... facts) { _rule.given(facts); mapGivenFactsToProperties(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test public void givenAttributesShouldMapToFacts() throws InvalidClassException { SampleRuleWithResult sampleRuleWithResult = new SampleRuleWithResult(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRuleWithResult); ruleAdapter.given(_factMap); Assert.assertEquals("FirstFact", sampleRuleWithResult.getFact1()); Assert.assertEquals("SecondFact", sampleRuleWithResult.getFact2()); Assert.assertEquals(1, sampleRuleWithResult.getValue1()); }
|
RuleAdapter implements Decision { @Override public Predicate getWhen() { if (_rule.getWhen() != null) { return _rule.getWhen(); } return Arrays.stream(_rulePojo.getClass().getMethods()) .filter(method -> method.getReturnType() == boolean.class || method.getReturnType() == Boolean.class) .filter(method -> Arrays.stream(method.getDeclaredAnnotations()).anyMatch(When.class::isInstance)) .findFirst() .<Predicate>map(method -> object -> { try { return (Boolean) method.invoke(_rulePojo); } catch (InvocationTargetException | IllegalAccessException ex) { LOGGER.error( "Unable to validate condition due to an exception. Condition will be interpreted as false", ex); return false; } }) .orElse(o -> false); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test public void pojoWithNoWhenAnnotationDefaultsToFalse() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Predicate predicate = ruleAdapter.getWhen(); Assert.assertFalse(predicate.test(null)); }
|
RuleAdapter implements Decision { @Override public List<Object> getThen() { if ((_rule.getThen()).size() < 1) { List<Object> thenList = new ArrayList<>(); for (Method thenMethod : getAnnotatedMethods(Then.class, _rulePojo.getClass())) { thenMethod.setAccessible(true); Object then = getThenMethodAsBiConsumer(thenMethod).map(Object.class::cast) .orElse(getThenMethodAsConsumer(thenMethod).orElse(factMap -> { })); thenList.add(then); } (_rule.getThen()).addAll(thenList); } return _rule.getThen(); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test public void pojoWithNoThenAnnotationDefaultsToNext() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Assert.assertEquals(0, ((List<Object>)ruleAdapter.getThen()).size()); }
|
RuleAdapter implements Decision { @Override public Decision stop() { _rule.stop(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test public void stopMethodShouldDelegateToRuleStopMethod() throws InvalidClassException { Rule rule = mock(Rule.class); RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); Decision retVal = ruleAdapter.stop(); Assert.assertEquals(retVal, ruleAdapter); verify(rule, times(1)).stop(); }
|
RuleAdapter implements Decision { @Override public Decision using(String... factName) { throw new UnsupportedOperationException(); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test(expected = UnsupportedOperationException.class) public void usingMethodShouldThrowNotImplemented() throws InvalidClassException { RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult()); ruleAdapter.using(); }
|
RuleAdapter implements Decision { @Override public Decision givenUnTyped(FactMap facts) { _rule.givenUnTyped(facts); mapGivenFactsToProperties(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }
|
@Test public void givenUnTypedMethodShouldDelegateToRuleGivenUnTypedMethod() throws InvalidClassException { Rule rule = mock(Rule.class); RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); Decision retVal = ruleAdapter.givenUnTyped(new FactMap()); Assert.assertEquals(retVal, ruleAdapter); verify(rule, times(1)).givenUnTyped(any(FactMap.class)); }
|
Fact implements NameValueReferable<T> { @Override public int hashCode() { return (_name.hashCode() + _value.hashCode()) % Integer.MAX_VALUE; } Fact(String name, T value); Fact(T obj); Fact(NameValueReferable<T> fact); @Override String getName(); @Override void setName(String name); @Override T getValue(); @Override void setValue(T value); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void equivalentFactsShouldHaveTheSametHashCode() { Fact<String> fact1 = new Fact<String>("fact1", "Fact One"); Fact<String> fact2 = new Fact<String>("fact1", "Fact One"); Fact<Double> fact3 = new Fact<Double>("fact2", 1.25); Fact<Double> fact4 = new Fact<Double>("fact2", 1.25); Assert.assertEquals(fact3, fact4); Assert.assertEquals(fact1, fact2); Assert.assertEquals(fact1.hashCode(), fact2.hashCode()); Assert.assertEquals(fact3.hashCode(), fact4.hashCode()); Assert.assertNotEquals(fact1, fact3); }
|
StandardRule implements Rule<T> { public static <T> StandardRule<T> create(Class<T> factType) { return new StandardRule<>(factType); } protected StandardRule(); StandardRule(Class<T> clazz); static StandardRule<T> create(Class<T> factType); static StandardRule<Object> create(); @Override @SuppressWarnings("unchecked") void run(Object... otherArgs); @Override @SuppressWarnings("unchecked") Rule<T> given(String name, T value); @Override @SuppressWarnings("unchecked") Rule<T> given(Fact<T>... facts); @SuppressWarnings("unchecked") @Override Rule<T> given(List<Fact<T>> facts); @Override Rule<T> given(FactMap<T> facts); @Override Rule<T> givenUnTyped(FactMap facts); @Override FactMap getFactMap(); @Override Rule<T> when(Predicate<FactMap<T>> test); @Override @SuppressWarnings("unchecked") Rule<T> then(Consumer<FactMap<T>> action); @Override Rule<T> stop(); @Override @SuppressWarnings("unchecked") StandardRule<T> using(String... factNames); @Override void setNextRule(Rule<T> rule); @Override Predicate<FactMap<T>> getWhen(); @Override List<Object> getThen(); }
|
@Test public void standardRuleIsCreated() { Rule<String> rule1 = new StandardRule<>(String.class); Rule<String> rule2 = StandardRule.create(String.class); Rule rule3 = StandardRule.create(); Assert.assertNotNull(rule1); Assert.assertNotNull(rule2); Assert.assertNotNull(rule3); }
|
SpringRuleBook implements RuleBook<T> { @Override public void addRule(Rule rule) { _ruleBook.addRule(rule); } SpringRuleBook(RuleBook<T> ruleBook); @Override void addRule(Rule rule); void addRule(Object rule); @Override void run(NameValueReferableMap facts); @Override void setDefaultResult(T result); @Override Optional<Result<T>> getResult(); @Override boolean hasRules(); }
|
@Test public void addingRulesToSpringRuleBookShouldAddTheRuleToTheDelegate() throws InvalidClassException { RuleBook<String> mockRuleBook = (RuleBook<String>)mock(CoRRuleBook.class); SpringRuleBook<String> ruleBook = new SpringRuleBook<>(mockRuleBook); Rule rule = RuleBuilder.create().build(); ruleBook.addRule(rule); Mockito.verify(mockRuleBook, times(1)).addRule(rule); }
|
SpringRuleBook implements RuleBook<T> { @Override public boolean hasRules() { return _ruleBook.hasRules(); } SpringRuleBook(RuleBook<T> ruleBook); @Override void addRule(Rule rule); void addRule(Object rule); @Override void run(NameValueReferableMap facts); @Override void setDefaultResult(T result); @Override Optional<Result<T>> getResult(); @Override boolean hasRules(); }
|
@Test public void springRuleBooksWithNoRulesShouldReturnFalseForHasRules() { SpringRuleBook<String> ruleBook = new SpringRuleBook<>(_ruleBook); Assert.assertFalse(ruleBook.hasRules()); }
|
RuleBookBean extends DecisionBook { @SuppressWarnings("unchecked") public void addRule(Object rule) throws InvalidClassException { super.addRule(new RuleAdapter(rule)); } @SuppressWarnings("unchecked") void addRule(Object rule); }
|
@Test(expected = InvalidClassException.class) public void ruleBookBeanShouldHandlePojosInRuleAdapterWithNoAnnotation() throws InvalidClassException { RuleBookBean ruleBookBean = new RuleBookBean(); ruleBookBean.addRule(new Object()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.