Skip to content

Commit 9d14448

Browse files
sbrannensbrannen
committed
Improve SpEL tests for Elvis and Ternary operators
(cherry picked from commit 21f3b96)
1 parent b07bc2c commit 9d14448

2 files changed

Lines changed: 47 additions & 57 deletions

File tree

‎spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java‎

Lines changed: 23 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -151,12 +151,14 @@ void createObjectsOnAttemptToReferenceNull() {
151151

152152
@Test
153153
void elvisOperator() {
154-
evaluate("'Andy'?:'Dave'", "Andy", String.class);
155-
evaluate("null?:'Dave'", "Dave", String.class);
156-
evaluate("3?:1", 3, Integer.class);
157-
evaluate("(2*3)?:1*10", 6, Integer.class);
158-
evaluate("null?:2*10", 20, Integer.class);
159-
evaluate("(null?:1)*10", 10, Integer.class);
154+
evaluate("'Andy' ?: 'Dave'", "Andy", String.class);
155+
evaluate("null ?: 'Dave'", "Dave", String.class);
156+
evaluate("3 ?: 1", 3, Integer.class);
157+
evaluate("(2 * 3) ?: 1 * 10", 6, Integer.class);
158+
evaluate("null ?: 2 * 10", 20, Integer.class);
159+
evaluate("(null ?: 1) * 10", 10, Integer.class);
160+
evaluate("3 ?: #var = 5", 3, Integer.class);
161+
evaluate("null ?: #var = 5", 5, Integer.class);
160162
}
161163

162164
@Test
@@ -721,59 +723,41 @@ void orWithNullValueOnRight() {
721723
class TernaryOperatorTests {
722724

723725
@Test
724-
void ternaryOperator01() {
725-
evaluate("2>4?1:2", 2, Integer.class);
726+
void ternaryExpressionWithNullConditionType() {
727+
// cannot convert null to boolean
728+
evaluateAndCheckError("null ? 0 : 1", SpelMessage.TYPE_CONVERSION_ERROR);
726729
}
727730

728731
@Test
729-
void ternaryOperator02() {
730-
evaluate("'abc'=='abc'?1:2", 1, Integer.class);
731-
}
732-
733-
@Test
734-
void ternaryOperator03() {
732+
void ternaryExpressionWithInvalidConditionType() {
735733
// cannot convert String to boolean
736-
evaluateAndCheckError("'hello'?1:2", SpelMessage.TYPE_CONVERSION_ERROR);
737-
}
738-
739-
@Test
740-
void ternaryOperator04() {
741-
Expression e = parser.parseExpression("1>2?3:4");
742-
assertThat(e.isWritable(context)).isFalse();
734+
evaluateAndCheckError("'hello' ? 1 : 2", SpelMessage.TYPE_CONVERSION_ERROR);
743735
}
744736

745737
@Test
746-
void ternaryOperator05() {
747-
evaluate("1>2?#var=4:#var=5", 5, Integer.class);
748-
evaluate("3?:#var=5", 3, Integer.class);
749-
evaluate("null?:#var=5", 5, Integer.class);
750-
evaluate("2>4?(3>2?true:false):(5<3?true:false)", false, Boolean.class);
738+
void ternaryExpressionIsNotWritable() {
739+
Expression exp = parser.parseExpression("1 > 2 ? 3 : 4");
740+
assertThat(exp.isWritable(context)).isFalse();
751741
}
752742

753743
@Test
754-
void ternaryOperator06() {
755-
evaluate("3?:#var=5", 3, Integer.class);
756-
evaluate("null?:#var=5", 5, Integer.class);
757-
evaluate("2>4?(3>2?true:false):(5<3?true:false)", false, Boolean.class);
744+
void ternaryExpressions() {
745+
evaluate("2 > 4 ? 1 : 2", 2, Integer.class);
746+
evaluate("'abc' == 'abc' ? 1 : 2", 1, Integer.class);
747+
evaluate("1 > 2 ? #var = 4 : #var = 5", 5, Integer.class);
748+
evaluate("2 > 4 ? (3 > 2 ? true : false) : (5 < 3 ? true : false)", false, Boolean.class);
758749
}
759750

760751
@Test
761-
void ternaryExpressionWithImplicitGrouping() {
752+
void ternaryExpressionsWithImplicitGrouping() {
762753
evaluate("4 % 2 == 0 ? 2 : 3 * 10", 2, Integer.class);
763754
evaluate("4 % 2 == 1 ? 2 : 3 * 10", 30, Integer.class);
764755
}
765756

766757
@Test
767-
void ternaryExpressionWithExplicitGrouping() {
758+
void ternaryExpressionsWithExplicitGrouping() {
768759
evaluate("((4 % 2 == 0) ? 2 : 1) * 10", 20, Integer.class);
769760
}
770-
771-
@Test
772-
void ternaryOperatorWithNullValue() {
773-
assertThatExceptionOfType(EvaluationException.class)
774-
.isThrownBy(parser.parseExpression("null ? 0 : 1")::getValue);
775-
}
776-
777761
}
778762

779763
@Nested

‎spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java‎

Lines changed: 24 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -2055,24 +2055,27 @@ void operatorNot() {
20552055

20562056
@Test
20572057
void ternary() {
2058-
Expression expression = parser.parseExpression("true?'a':'b'");
2058+
expression = parser.parseExpression("true?'a':'b'");
20592059
String resultI = expression.getValue(String.class);
20602060
assertCanCompile(expression);
20612061
String resultC = expression.getValue(String.class);
20622062
assertThat(resultI).isEqualTo("a");
20632063
assertThat(resultC).isEqualTo("a");
2064+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
20642065

20652066
expression = parser.parseExpression("false?'a':'b'");
20662067
resultI = expression.getValue(String.class);
20672068
assertCanCompile(expression);
20682069
resultC = expression.getValue(String.class);
20692070
assertThat(resultI).isEqualTo("b");
20702071
assertThat(resultC).isEqualTo("b");
2072+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
20712073

20722074
expression = parser.parseExpression("false?1:'b'");
20732075
// All literals so we can do this straight away
20742076
assertCanCompile(expression);
20752077
assertThat(expression.getValue()).isEqualTo("b");
2078+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
20762079

20772080
boolean root = true;
20782081
expression = parser.parseExpression("(#root and true)?T(Integer).valueOf(1):T(Long).valueOf(3L)");
@@ -2082,21 +2085,25 @@ void ternary() {
20822085
assertThat(expression.getValue(root)).isEqualTo(3L);
20832086
assertCanCompile(expression);
20842087
assertThat(expression.getValue(root)).isEqualTo(3L);
2088+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
20852089
root = true;
20862090
assertThat(expression.getValue(root)).isEqualTo(1);
2091+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
20872092
}
20882093

2089-
@Test
2090-
void ternaryWithBooleanReturn_SPR12271() {
2094+
@Test // gh-16876
2095+
void ternaryWithBooleanWrapperCondition() {
20912096
expression = parser.parseExpression("T(Boolean).TRUE?'abc':'def'");
20922097
assertThat(expression.getValue()).isEqualTo("abc");
20932098
assertCanCompile(expression);
20942099
assertThat(expression.getValue()).isEqualTo("abc");
2100+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
20952101

20962102
expression = parser.parseExpression("T(Boolean).FALSE?'abc':'def'");
20972103
assertThat(expression.getValue()).isEqualTo("def");
20982104
assertCanCompile(expression);
20992105
assertThat(expression.getValue()).isEqualTo("def");
2106+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
21002107
}
21012108

21022109
@Test
@@ -2288,31 +2295,30 @@ void nullsafeMethodChaining_SPR16489() {
22882295

22892296
@Test
22902297
void elvis() {
2291-
Expression expression = parser.parseExpression("'a'?:'b'");
2292-
String resultI = expression.getValue(String.class);
2298+
expression = parser.parseExpression("'a' ?: 'b'");
2299+
assertThat(expression.getValue(String.class)).isEqualTo("a");
22932300
assertCanCompile(expression);
2294-
String resultC = expression.getValue(String.class);
2295-
assertThat(resultI).isEqualTo("a");
2296-
assertThat(resultC).isEqualTo("a");
2301+
assertThat(expression.getValue(String.class)).isEqualTo("a");
2302+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
22972303

2298-
expression = parser.parseExpression("null?:'a'");
2299-
resultI = expression.getValue(String.class);
2304+
expression = parser.parseExpression("null ?: 'a'");
2305+
assertThat(expression.getValue(String.class)).isEqualTo("a");
23002306
assertCanCompile(expression);
2301-
resultC = expression.getValue(String.class);
2302-
assertThat(resultI).isEqualTo("a");
2303-
assertThat(resultC).isEqualTo("a");
2307+
assertThat(expression.getValue(String.class)).isEqualTo("a");
2308+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
23042309

2305-
String s = "abc";
2306-
expression = parser.parseExpression("#root?:'b'");
2310+
String root = "abc";
2311+
expression = parser.parseExpression("#root ?: 'b'");
23072312
assertCannotCompile(expression);
2308-
resultI = expression.getValue(s, String.class);
2309-
assertThat(resultI).isEqualTo("abc");
2313+
assertThat(expression.getValue(root, String.class)).isEqualTo("abc");
23102314
assertCanCompile(expression);
2315+
assertThat(expression.getValue(root, String.class)).isEqualTo("abc");
2316+
assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
23112317
}
23122318

23132319

23142320
public static String concat(String a, String b) {
2315-
return a+b;
2321+
return a + b;
23162322
}
23172323

23182324
public static String concat2(Object... args) {

0 commit comments

Comments
 (0)