GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Polishing

pull/32141/head
Sam Brannen 2 years ago
parent
500767a0fb
commit
3024c6efa9
4 changed files with 88 additions and 105 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 146
      spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
  2. 18
      spring-expression/src/test/java/org/springframework/expression/spel/MethodInvocationTests.java
  3. 11
      spring-expression/src/test/java/org/springframework/expression/spel/SpelReproTests.java
  4. 18
      spring-expression/src/test/java/org/springframework/expression/spel/support/StandardEvaluationContextTests.java

146
spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
Unescape View File

@ -108,8 +108,8 @@ class EvaluationTests extends AbstractExpressionTests {
assertThat(o).isEqualTo(""); assertThat(o).isEqualTo("");
assertThat(testClass.list).hasSize(4); assertThat(testClass.list).hasSize(4);
assertThatExceptionOfType(EvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("list2[3]").getValue(new StandardEvaluationContext(testClass))); .isThrownBy(() -> parser.parseExpression("list2[3]").getValue(new StandardEvaluationContext(testClass)));
o = parser.parseExpression("foo[3]").getValue(new StandardEvaluationContext(testClass)); o = parser.parseExpression("foo[3]").getValue(new StandardEvaluationContext(testClass));
assertThat(o).isEqualTo(""); assertThat(o).isEqualTo("");
@ -127,8 +127,8 @@ class EvaluationTests extends AbstractExpressionTests {
o = parser.parseExpression("map").getValue(ctx); o = parser.parseExpression("map").getValue(ctx);
assertThat(o).isNotNull(); assertThat(o).isNotNull();
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
parser.parseExpression("map2['a']").getValue(ctx)); .isThrownBy(() -> parser.parseExpression("map2['a']").getValue(ctx));
// map2 should be null, there is no setter // map2 should be null, there is no setter
} }
@ -144,8 +144,8 @@ class EvaluationTests extends AbstractExpressionTests {
o = parser.parseExpression("wibble").getValue(ctx); o = parser.parseExpression("wibble").getValue(ctx);
assertThat(o).isNotNull(); assertThat(o).isNotNull();
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
parser.parseExpression("wibble2.bar").getValue(ctx)); .isThrownBy(() -> parser.parseExpression("wibble2.bar").getValue(ctx));
} }
@Test @Test
@ -270,8 +270,8 @@ class EvaluationTests extends AbstractExpressionTests {
@Test @Test
void resolvingList() { void resolvingList() {
StandardEvaluationContext context = TestScenarioCreator.getTestEvaluationContext(); StandardEvaluationContext context = TestScenarioCreator.getTestEvaluationContext();
assertThatExceptionOfType(EvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("T(List)!=null").getValue(context, Boolean.class)); .isThrownBy(() -> parser.parseExpression("T(List)!=null").getValue(context, Boolean.class));
((StandardTypeLocator) context.getTypeLocator()).registerImport("java.util"); ((StandardTypeLocator) context.getTypeLocator()).registerImport("java.util");
assertThat(parser.parseExpression("T(List)!=null").getValue(context, Boolean.class)).isTrue(); assertThat(parser.parseExpression("T(List)!=null").getValue(context, Boolean.class)).isTrue();
} }
@ -343,8 +343,8 @@ class EvaluationTests extends AbstractExpressionTests {
// Register a custom MethodFilter... // Register a custom MethodFilter...
MethodFilter methodFilter = methods -> null; MethodFilter methodFilter = methods -> null;
assertThatIllegalStateException() assertThatIllegalStateException()
.isThrownBy(() -> context.registerMethodFilter(String.class, methodFilter)) .isThrownBy(() -> context.registerMethodFilter(String.class, methodFilter))
.withMessage("Method filter cannot be set as the reflective method resolver is not in use"); .withMessage("Method filter cannot be set as the reflective method resolver is not in use");
} }
/** /**
@ -380,9 +380,9 @@ class EvaluationTests extends AbstractExpressionTests {
StandardEvaluationContext failCtx = new StandardEvaluationContext(instance); StandardEvaluationContext failCtx = new StandardEvaluationContext(instance);
parser = new SpelExpressionParser(new SpelParserConfiguration(false, false)); parser = new SpelExpressionParser(new SpelParserConfiguration(false, false));
Expression failExp = parser.parseExpression("listOfStrings[3]"); Expression failExp = parser.parseExpression("listOfStrings[3]");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
failExp.getValue(failCtx, String.class)) .isThrownBy(() -> failExp.getValue(failCtx, String.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.COLLECTION_INDEX_OUT_OF_BOUNDS)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.COLLECTION_INDEX_OUT_OF_BOUNDS));
} }
@Test @Test
@ -567,12 +567,12 @@ class EvaluationTests extends AbstractExpressionTests {
@Test @Test
void rogueTrailingDotCausesNPE_SPR6866() { void rogueTrailingDotCausesNPE_SPR6866() {
assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> assertThatExceptionOfType(SpelParseException.class)
new SpelExpressionParser().parseExpression("placeOfBirth.foo.")) .isThrownBy(() -> new SpelExpressionParser().parseExpression("placeOfBirth.foo."))
.satisfies(ex -> { .satisfies(ex -> {
assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OOD); assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OOD);
assertThat(ex.getPosition()).isEqualTo(16); assertThat(ex.getPosition()).isEqualTo(16);
}); });
} }
@Nested @Nested
@ -591,12 +591,12 @@ class EvaluationTests extends AbstractExpressionTests {
@Test @Test
void propertiesNested03() throws ParseException { void propertiesNested03() throws ParseException {
assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> assertThatExceptionOfType(SpelParseException.class)
new SpelExpressionParser().parseRaw("placeOfBirth.23")) .isThrownBy(() -> new SpelExpressionParser().parseRaw("placeOfBirth.23"))
.satisfies(ex -> { .satisfies(ex -> {
assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.UNEXPECTED_DATA_AFTER_DOT); assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.UNEXPECTED_DATA_AFTER_DOT);
assertThat(ex.getInserts()[0]).isEqualTo("23"); assertThat(ex.getInserts()[0]).isEqualTo("23");
}); });
} }
} }
@ -680,26 +680,26 @@ class EvaluationTests extends AbstractExpressionTests {
@Test @Test
void andWithNullValueOnLeft() { void andWithNullValueOnLeft() {
assertThatExceptionOfType(EvaluationException.class).isThrownBy( assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("null and true")::getValue); .isThrownBy(parser.parseExpression("null and true")::getValue);
} }
@Test @Test
void andWithNullValueOnRight() { void andWithNullValueOnRight() {
assertThatExceptionOfType(EvaluationException.class).isThrownBy( assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("true and null")::getValue); .isThrownBy(parser.parseExpression("true and null")::getValue);
} }
@Test @Test
void orWithNullValueOnLeft() { void orWithNullValueOnLeft() {
assertThatExceptionOfType(EvaluationException.class).isThrownBy( assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("null or false")::getValue); .isThrownBy(parser.parseExpression("null or false")::getValue);
} }
@Test @Test
void orWithNullValueOnRight() { void orWithNullValueOnRight() {
assertThatExceptionOfType(EvaluationException.class).isThrownBy( assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("false or null")::getValue); .isThrownBy(parser.parseExpression("false or null")::getValue);
} }
} }
@ -757,8 +757,8 @@ class EvaluationTests extends AbstractExpressionTests {
@Test @Test
void ternaryOperatorWithNullValue() { void ternaryOperatorWithNullValue() {
assertThatExceptionOfType(EvaluationException.class).isThrownBy( assertThatExceptionOfType(EvaluationException.class)
parser.parseExpression("null ? 0 : 1")::getValue); .isThrownBy(parser.parseExpression("null ? 0 : 1")::getValue);
} }
} }
@ -859,9 +859,9 @@ class EvaluationTests extends AbstractExpressionTests {
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e = parser.parseExpression("#this++"); Expression e = parser.parseExpression("#this++");
assertThat(i).isEqualTo(42); assertThat(i).isEqualTo(42);
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e.getValue(ctx, Integer.class)) .isThrownBy(() -> e.getValue(ctx, Integer.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
} }
@Test @Test
@ -977,14 +977,14 @@ class EvaluationTests extends AbstractExpressionTests {
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e1 = parser.parseExpression("m()++"); Expression e1 = parser.parseExpression("m()++");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE));
Expression e2 = parser.parseExpression("++m()"); Expression e2 = parser.parseExpression("++m()");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE));
} }
@Test @Test
@ -993,13 +993,13 @@ class EvaluationTests extends AbstractExpressionTests {
StandardEvaluationContext ctx = new StandardEvaluationContext(i); StandardEvaluationContext ctx = new StandardEvaluationContext(i);
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e1 = parser.parseExpression("++1"); Expression e1 = parser.parseExpression("++1");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
Expression e2 = parser.parseExpression("1++"); Expression e2 = parser.parseExpression("1++");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
} }
@Test @Test
@ -1009,9 +1009,9 @@ class EvaluationTests extends AbstractExpressionTests {
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e = parser.parseExpression("#this--"); Expression e = parser.parseExpression("#this--");
assertThat(i).isEqualTo(42); assertThat(i).isEqualTo(42);
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e.getValue(ctx, Integer.class)) .isThrownBy(() -> e.getValue(ctx, Integer.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
} }
@Test @Test
@ -1127,14 +1127,14 @@ class EvaluationTests extends AbstractExpressionTests {
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e1 = parser.parseExpression("m()--"); Expression e1 = parser.parseExpression("m()--");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE));
Expression e2 = parser.parseExpression("--m()"); Expression e2 = parser.parseExpression("--m()");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, Double.TYPE))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE));
} }
@Test @Test
@ -1143,14 +1143,14 @@ class EvaluationTests extends AbstractExpressionTests {
StandardEvaluationContext ctx = new StandardEvaluationContext(i); StandardEvaluationContext ctx = new StandardEvaluationContext(i);
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e1 = parser.parseExpression("--1"); Expression e1 = parser.parseExpression("--1");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e1.getValue(ctx, Integer.class)) .isThrownBy(() -> e1.getValue(ctx, Integer.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
Expression e2 = parser.parseExpression("1--"); Expression e2 = parser.parseExpression("1--");
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> assertThatExceptionOfType(SpelEvaluationException.class)
e2.getValue(ctx, Integer.class)) .isThrownBy(() -> e2.getValue(ctx, Integer.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
} }
@Test @Test
@ -1508,13 +1508,15 @@ class EvaluationTests extends AbstractExpressionTests {
} }
private void expectFail(ExpressionParser parser, EvaluationContext eContext, String expressionString, SpelMessage messageCode) { private void expectFail(ExpressionParser parser, EvaluationContext eContext, String expressionString, SpelMessage messageCode) {
assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() -> { assertThatExceptionOfType(SpelEvaluationException.class)
Expression e = parser.parseExpression(expressionString); .isThrownBy(() -> {
if (DEBUG) { Expression e = parser.parseExpression(expressionString);
SpelUtilities.printAbstractSyntaxTree(System.out, e); if (DEBUG) {
} SpelUtilities.printAbstractSyntaxTree(System.out, e);
e.getValue(eContext); }
}).satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(messageCode)); e.getValue(eContext);
})
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(messageCode));
} }
} }

18
spring-expression/src/test/java/org/springframework/expression/spel/MethodInvocationTests.java
Unescape View File

@ -25,11 +25,8 @@ import java.util.List;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression; import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionInvocationTargetException; import org.springframework.expression.ExpressionInvocationTargetException;
import org.springframework.expression.MethodExecutor;
import org.springframework.expression.MethodFilter; import org.springframework.expression.MethodFilter;
import org.springframework.expression.MethodResolver; import org.springframework.expression.MethodResolver;
import org.springframework.expression.spel.standard.SpelExpression; import org.springframework.expression.spel.standard.SpelExpression;
@ -221,7 +218,10 @@ class MethodInvocationTests extends AbstractExpressionTests {
List<MethodResolver> methodResolvers = ctx.getMethodResolvers(); List<MethodResolver> methodResolvers = ctx.getMethodResolvers();
assertThat(methodResolvers).hasSize(1); assertThat(methodResolvers).hasSize(1);
MethodResolver dummy = new DummyMethodResolver(); MethodResolver dummy = (context, targetObject, name, argumentTypes) -> {
throw new UnsupportedOperationException();
};
ctx.addMethodResolver(dummy); ctx.addMethodResolver(dummy);
assertThat(ctx.getMethodResolvers()).hasSize(2); assertThat(ctx.getMethodResolvers()).hasSize(2);
@ -389,16 +389,6 @@ class MethodInvocationTests extends AbstractExpressionTests {
} }
static class DummyMethodResolver implements MethodResolver {
@Override
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
List<TypeDescriptor> argumentTypes) {
throw new UnsupportedOperationException();
}
}
public static class BytesService { public static class BytesService {
public byte[] handleBytes(byte[] bytes) { public byte[] handleBytes(byte[] bytes) {

11
spring-expression/src/test/java/org/springframework/expression/spel/SpelReproTests.java
Unescape View File

@ -63,6 +63,7 @@ import org.springframework.expression.spel.support.StandardTypeLocator;
import org.springframework.expression.spel.testresources.le.div.mod.reserved.Reserver; import org.springframework.expression.spel.testresources.le.div.mod.reserved.Reserver;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatException; import static org.assertj.core.api.Assertions.assertThatException;
@ -842,16 +843,10 @@ class SpelReproTests extends AbstractExpressionTests {
void customStaticFunctions_SPR9038() { void customStaticFunctions_SPR9038() {
ExpressionParser parser = new SpelExpressionParser(); ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext(); StandardEvaluationContext context = new StandardEvaluationContext();
List<MethodResolver> methodResolvers = new ArrayList<>(); List<MethodResolver> methodResolvers = List.of(new ReflectiveMethodResolver() {
methodResolvers.add(new ReflectiveMethodResolver() {
@Override @Override
protected Method[] getMethods(Class<?> type) { protected Method[] getMethods(Class<?> type) {
try { return new Method[] {ReflectionUtils.findMethod(Integer.class, "parseInt", String.class, int.class)};
return new Method[] {Integer.class.getDeclaredMethod("parseInt", String.class, Integer.TYPE)};
}
catch (NoSuchMethodException ex) {
return new Method[0];
}
} }
}); });

18
spring-expression/src/test/java/org/springframework/expression/spel/support/StandardEvaluationContextTests.java
Unescape View File

@ -20,13 +20,9 @@ import java.util.ArrayList;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.ConstructorResolver; import org.springframework.expression.ConstructorResolver;
import org.springframework.expression.MethodResolver; import org.springframework.expression.MethodResolver;
import org.springframework.expression.OperatorOverloader;
import org.springframework.expression.PropertyAccessor; import org.springframework.expression.PropertyAccessor;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.TypeLocator;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
@ -57,10 +53,10 @@ class StandardEvaluationContextTests {
@Test @Test
void applyDelegatesToSetOverrideDelegatesInTarget() { void applyDelegatesToSetOverrideDelegatesInTarget() {
StandardEvaluationContext target = new StandardEvaluationContext(); StandardEvaluationContext target = new StandardEvaluationContext();
target.setBeanResolver(mock(BeanResolver.class)); target.setBeanResolver(mock());
target.setTypeLocator(mock(TypeLocator.class)); target.setTypeLocator(mock());
target.setTypeConverter(mock(TypeConverter.class)); target.setTypeConverter(mock());
target.setOperatorOverloader(mock(OperatorOverloader.class)); target.setOperatorOverloader(mock());
target.setPropertyAccessors(new ArrayList<>()); target.setPropertyAccessors(new ArrayList<>());
target.setConstructorResolvers(new ArrayList<>()); target.setConstructorResolvers(new ArrayList<>());
target.setMethodResolvers(new ArrayList<>()); target.setMethodResolvers(new ArrayList<>());
@ -79,7 +75,7 @@ class StandardEvaluationContextTests {
void applyDelegatesToMakesACopyOfPropertyAccessors() { void applyDelegatesToMakesACopyOfPropertyAccessors() {
StandardEvaluationContext target = new StandardEvaluationContext(); StandardEvaluationContext target = new StandardEvaluationContext();
this.evaluationContext.applyDelegatesTo(target); this.evaluationContext.applyDelegatesTo(target);
PropertyAccessor propertyAccessor = mock(PropertyAccessor.class); PropertyAccessor propertyAccessor = mock();
this.evaluationContext.getPropertyAccessors().add(propertyAccessor); this.evaluationContext.getPropertyAccessors().add(propertyAccessor);
assertThat(target.getPropertyAccessors()).doesNotContain(propertyAccessor); assertThat(target.getPropertyAccessors()).doesNotContain(propertyAccessor);
} }
@ -88,7 +84,7 @@ class StandardEvaluationContextTests {
void applyDelegatesToMakesACopyOfConstructorResolvers() { void applyDelegatesToMakesACopyOfConstructorResolvers() {
StandardEvaluationContext target = new StandardEvaluationContext(); StandardEvaluationContext target = new StandardEvaluationContext();
this.evaluationContext.applyDelegatesTo(target); this.evaluationContext.applyDelegatesTo(target);
ConstructorResolver methodResolver = mock(ConstructorResolver.class); ConstructorResolver methodResolver = mock();
this.evaluationContext.getConstructorResolvers().add(methodResolver); this.evaluationContext.getConstructorResolvers().add(methodResolver);
assertThat(target.getConstructorResolvers()).doesNotContain(methodResolver); assertThat(target.getConstructorResolvers()).doesNotContain(methodResolver);
} }
@ -97,7 +93,7 @@ class StandardEvaluationContextTests {
void applyDelegatesToMakesACopyOfMethodResolvers() { void applyDelegatesToMakesACopyOfMethodResolvers() {
StandardEvaluationContext target = new StandardEvaluationContext(); StandardEvaluationContext target = new StandardEvaluationContext();
this.evaluationContext.applyDelegatesTo(target); this.evaluationContext.applyDelegatesTo(target);
MethodResolver methodResolver = mock(MethodResolver.class); MethodResolver methodResolver = mock();
this.evaluationContext.getMethodResolvers().add(methodResolver); this.evaluationContext.getMethodResolvers().add(methodResolver);
assertThat(target.getMethodResolvers()).doesNotContain(methodResolver); assertThat(target.getMethodResolvers()).doesNotContain(methodResolver);
} }

Write Preview
Loading…
Cancel
Save