Skip to content
This repository was archived by the owner on Aug 2, 2022. It is now read-only.

Commit e2f159b

Browse files
harold-wangharold-wang
committed
* Use ParameterizedTest for UT
1 parent 87049c1 commit e2f159b

File tree

2 files changed

+126
-90
lines changed

2 files changed

+126
-90
lines changed

‎core/src/test/java/com/amazon/opendistroforelasticsearch/sql/expression/ExpressionTestBase.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ public class ExpressionTestBase {
6363
protected Environment<Expression, ExprType> typeEnv;
6464

6565
@Bean
66-
protected Environment<Expression, ExprValue> valueEnv() {
66+
protected static Environment<Expression, ExprValue> valueEnv() {
6767
return var -> {
6868
if (var instanceof ReferenceExpression) {
6969
switch (((ReferenceExpression) var).getAttr()) {

‎core/src/test/java/com/amazon/opendistroforelasticsearch/sql/expression/operator/predicate/UnaryPredicateOperatorTest.java

+125-89
Original file line numberDiff line numberDiff line change
@@ -23,21 +23,29 @@
2323
import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
2424
import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.booleanValue;
2525
import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.BOOLEAN;
26+
import static java.lang.Enum.valueOf;
2627
import static org.junit.jupiter.api.Assertions.assertEquals;
2728

2829
import com.amazon.opendistroforelasticsearch.sql.data.model.ExprNullValue;
2930
import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
3031
import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils;
32+
import com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType;
3133
import com.amazon.opendistroforelasticsearch.sql.expression.DSL;
3234
import com.amazon.opendistroforelasticsearch.sql.expression.Expression;
3335
import com.amazon.opendistroforelasticsearch.sql.expression.ExpressionTestBase;
3436
import com.amazon.opendistroforelasticsearch.sql.expression.FunctionExpression;
35-
37+
import com.google.common.collect.Lists;
3638
import java.lang.reflect.Array;
3739
import java.util.ArrayList;
40+
import java.util.Arrays;
41+
import java.util.List;
42+
import java.util.stream.Collectors;
43+
import java.util.stream.Stream;
3844

3945
import org.junit.jupiter.api.Test;
4046
import org.junit.jupiter.params.ParameterizedTest;
47+
import org.junit.jupiter.params.provider.Arguments;
48+
import org.junit.jupiter.params.provider.MethodSource;
4149
import org.junit.jupiter.params.provider.ValueSource;
4250

4351
class UnaryPredicateOperatorTest extends ExpressionTestBase {
@@ -50,6 +58,100 @@ public void test_not(Boolean v) {
5058
assertEquals(String.format("not(%s)", v.toString()), not.toString());
5159
}
5260

61+
private static Stream<Arguments> isNullArguments() {
62+
ArrayList<Expression> expressions = new ArrayList<>();
63+
expressions.add(DSL.literal("test"));
64+
expressions.add(DSL.literal(100));
65+
expressions.add(DSL.literal(""));
66+
expressions.add(DSL.literal(LITERAL_NULL));
67+
68+
return Lists.cartesianProduct(expressions, expressions).stream()
69+
.map(list -> {
70+
Expression e1 = list.get(0);
71+
if (e1.valueOf(valueEnv()).isNull()
72+
|| e1.valueOf(valueEnv()).isMissing()) {
73+
return Arguments.of(e1, DSL.literal(LITERAL_TRUE));
74+
} else {
75+
return Arguments.of(e1, DSL.literal(LITERAL_FALSE));
76+
}
77+
});
78+
}
79+
80+
private static Stream<Arguments> ifNullArguments() {
81+
ArrayList<Expression> exprValueArrayList = new ArrayList<>();
82+
exprValueArrayList.add(DSL.literal(123));
83+
exprValueArrayList.add(DSL.literal("test"));
84+
exprValueArrayList.add(DSL.literal(321));
85+
exprValueArrayList.add(DSL.literal(""));
86+
87+
return Lists.cartesianProduct(exprValueArrayList, exprValueArrayList).stream()
88+
.map(list -> {
89+
Expression e1 = list.get(0);
90+
Expression e2 = list.get(1);
91+
if (e1.valueOf(valueEnv()).value() == LITERAL_NULL.value()
92+
|| e1.valueOf(valueEnv()).value() == LITERAL_MISSING) {
93+
return Arguments.of(e1, e2, e2);
94+
} else {
95+
return Arguments.of(e1, e2, e1);
96+
}
97+
});
98+
}
99+
100+
private static Stream<Arguments> nullIfArguments() {
101+
ArrayList<Expression> exprValueArrayList = new ArrayList<>();
102+
exprValueArrayList.add(DSL.literal(123));
103+
exprValueArrayList.add(DSL.literal(321));
104+
105+
return Lists.cartesianProduct(exprValueArrayList, exprValueArrayList).stream()
106+
.map(list -> {
107+
Expression e1 = list.get(0);
108+
Expression e2 = list.get(1);
109+
110+
if (e1.equals(e2)) {
111+
return Arguments.of(e1, e2, DSL.literal(LITERAL_NULL));
112+
} else {
113+
return Arguments.of(e1, e2, e1);
114+
}
115+
});
116+
}
117+
118+
private static Stream<Arguments> exprIfNullArguments() {
119+
ArrayList<ExprValue> exprValues = new ArrayList<>();
120+
exprValues.add(LITERAL_NULL);
121+
exprValues.add(LITERAL_MISSING);
122+
exprValues.add(ExprValueUtils.integerValue(123));
123+
exprValues.add(ExprValueUtils.stringValue("test"));
124+
125+
return Lists.cartesianProduct(exprValues, exprValues).stream()
126+
.map(list -> {
127+
ExprValue e1 = list.get(0);
128+
ExprValue e2 = list.get(1);
129+
if (e1.isNull() || e1.isMissing()) {
130+
return Arguments.of(e1, e2, e2);
131+
} else {
132+
return Arguments.of(e1, e2, e1);
133+
}
134+
});
135+
}
136+
137+
private static Stream<Arguments> exprNullIfArguments() {
138+
ArrayList<ExprValue> exprValues = new ArrayList<>();
139+
exprValues.add(LITERAL_NULL);
140+
exprValues.add(LITERAL_MISSING);
141+
exprValues.add(ExprValueUtils.integerValue(123));
142+
143+
return Lists.cartesianProduct(exprValues, exprValues).stream()
144+
.map(list -> {
145+
ExprValue e1 = list.get(0);
146+
ExprValue e2 = list.get(1);
147+
if (e1.equals(e2)) {
148+
return Arguments.of(e1, e2, LITERAL_NULL);
149+
} else {
150+
return Arguments.of(e1, e2, e1);
151+
}
152+
});
153+
}
154+
53155
@Test
54156
public void test_not_null() {
55157
FunctionExpression expression = dsl.not(DSL.ref(BOOL_TYPE_NULL_VALUE_FIELD, BOOLEAN));
@@ -75,25 +177,6 @@ public void test_is_null_predicate() {
75177
assertEquals(LITERAL_TRUE, expression.valueOf(valueEnv()));
76178
}
77179

78-
@Test
79-
public void test_isnull_predicate() {
80-
ArrayList<Expression> exprValueArrayList = new ArrayList<>();
81-
exprValueArrayList.add(dsl.literal("test"));
82-
exprValueArrayList.add(dsl.literal(100));
83-
exprValueArrayList.add(dsl.literal(""));
84-
85-
for (Expression expression : exprValueArrayList) {
86-
FunctionExpression functionExpression = dsl.isnull(expression);
87-
assertEquals(BOOLEAN, functionExpression.type());
88-
if (expression.valueOf(valueEnv()) == LITERAL_NULL
89-
|| expression.valueOf(valueEnv()) == LITERAL_MISSING) {
90-
assertEquals(LITERAL_TRUE, functionExpression.valueOf(valueEnv()));
91-
} else {
92-
assertEquals(LITERAL_FALSE, functionExpression.valueOf(valueEnv()));
93-
}
94-
}
95-
}
96-
97180
@Test
98181
public void test_is_not_null_predicate() {
99182
FunctionExpression expression = dsl.isnotnull(DSL.literal(1));
@@ -105,81 +188,34 @@ public void test_is_not_null_predicate() {
105188
assertEquals(LITERAL_FALSE, expression.valueOf(valueEnv()));
106189
}
107190

108-
@Test
109-
public void test_ifnull_predicate() {
110-
ArrayList<Expression> exprValueArrayList = new ArrayList<>();
111-
exprValueArrayList.add(dsl.literal(100));
112-
exprValueArrayList.add(dsl.literal(200));
113-
114-
for (Expression expressionOne : exprValueArrayList) {
115-
for (Expression expressionTwo : exprValueArrayList) {
116-
FunctionExpression functionExpression = dsl.ifnull(expressionOne, expressionTwo);
117-
if (expressionOne.valueOf(valueEnv()) == LITERAL_NULL
118-
|| expressionOne.valueOf(valueEnv()) == LITERAL_MISSING) {
119-
assertEquals(expressionTwo.valueOf(valueEnv()), functionExpression.valueOf(valueEnv()));
120-
} else {
121-
assertEquals(expressionOne.valueOf(valueEnv()), functionExpression.valueOf(valueEnv()));
122-
}
123-
}
124-
}
125-
191+
@ParameterizedTest
192+
@MethodSource("isNullArguments")
193+
public void test_isnull_predicate(Expression v1, Expression expected) {
194+
assertEquals(expected.valueOf(valueEnv()), dsl.isnull(v1).valueOf(valueEnv()));
126195
}
127196

128-
@Test
129-
public void test_nullif_predicate() {
130-
ArrayList<Expression> exprValueArrayList = new ArrayList<>();
131-
exprValueArrayList.add(DSL.literal(123));
132-
exprValueArrayList.add(DSL.literal(321));
133-
134-
for (Expression v1 : exprValueArrayList) {
135-
for (Expression v2 : exprValueArrayList) {
136-
FunctionExpression result = dsl.nullif(v1, v2);
137-
if (v1.valueOf(valueEnv()) == v2.valueOf(valueEnv())) {
138-
assertEquals(LITERAL_NULL, result.valueOf(valueEnv()));
139-
} else {
140-
assertEquals(v1.valueOf(valueEnv()), result.valueOf(valueEnv()));
141-
}
142-
}
143-
}
197+
@ParameterizedTest
198+
@MethodSource("ifNullArguments")
199+
public void test_ifnull_predicate(Expression v1, Expression v2, Expression expected) {
200+
assertEquals(expected.valueOf(valueEnv()), dsl.ifnull(v1, v2).valueOf(valueEnv()));
144201
}
145202

146-
@Test
147-
public void test_exprIfNull() {
148-
ArrayList<ExprValue> exprValues = new ArrayList<>();
149-
exprValues.add(LITERAL_NULL);
150-
exprValues.add(LITERAL_MISSING);
151-
exprValues.add(ExprValueUtils.integerValue(123));
152-
exprValues.add(ExprValueUtils.stringValue("test"));
203+
@ParameterizedTest
204+
@MethodSource("exprIfNullArguments")
205+
public void test_exprIfNull_predicate(ExprValue v1, ExprValue v2, ExprValue expected) {
206+
assertEquals(expected.value(), UnaryPredicateOperator.exprIfNull(v1, v2).value());
207+
}
153208

154-
for (ExprValue exprValueOne : exprValues) {
155-
for (ExprValue exprValueTwo : exprValues) {
156-
ExprValue result = UnaryPredicateOperator.exprIfNull(exprValueOne, exprValueTwo);
157-
if (exprValueOne.isNull() || exprValueOne.isMissing()) {
158-
assertEquals(exprValueTwo.value(), result.value());
159-
} else {
160-
assertEquals(exprValueOne.value(), result.value());
161-
}
162-
}
163-
}
209+
@ParameterizedTest
210+
@MethodSource("nullIfArguments")
211+
public void test_nullif_predicate(Expression v1, Expression v2, Expression expected) {
212+
assertEquals(expected.valueOf(valueEnv()), dsl.nullif(v1, v2).valueOf(valueEnv()));
164213
}
165214

166-
@Test
167-
public void test_exprNullIf() {
168-
ArrayList<ExprValue> exprValues = new ArrayList<>();
169-
exprValues.add(LITERAL_NULL);
170-
exprValues.add(LITERAL_MISSING);
171-
exprValues.add(ExprValueUtils.integerValue(123));
172-
exprValues.add(ExprValueUtils.integerValue(456));
173-
174-
for (ExprValue exprValueOne : exprValues) {
175-
for (ExprValue exprValueTwo : exprValues) {
176-
ExprValue result = UnaryPredicateOperator.exprNullIf(exprValueOne, exprValueTwo);
177-
if (exprValueOne.equals(exprValueTwo)) {
178-
assertEquals(LITERAL_NULL.value(), result.value());
179-
} else {
180-
assertEquals(exprValueOne.value(), result.value());
181-
}
182-
}
183-
}
215+
@ParameterizedTest
216+
@MethodSource("exprNullIfArguments")
217+
public void test_exprNullIf_predicate(ExprValue v1, ExprValue v2, ExprValue expected) {
218+
assertEquals(expected.value(), UnaryPredicateOperator.exprNullIf(v1, v2).value());
184219
}
220+
185221
}

0 commit comments

Comments
 (0)