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

Fixed getTypeDifferenceWeight algorithm in ReflectionHelper, and removed unused argsRequiringConversion storage 

Issue: SPR-11306
pull/440/head
Juergen Hoeller 12 years ago
parent
5f2106046c
commit
5d06bcec70
6 changed files with 162 additions and 256 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 166
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java
  2. 10
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorExecutor.java
  3. 24
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorResolver.java
  4. 17
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodExecutor.java
  5. 13
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodResolver.java
  6. 188
      spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java

166
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java
Unescape View File

@ -18,7 +18,6 @@ package org.springframework.expression.spel.support; @@ -18,7 +18,6 @@ package org.springframework.expression.spel.support;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.springframework.core.MethodParameter;
@ -46,11 +45,9 @@ public class ReflectionHelper { @@ -46,11 +45,9 @@ public class ReflectionHelper {
* type converter and conversionAllowed flag allow for matches to take into account
* that a type may be transformed into a different type by the converter.
* @param expectedArgTypes the array of types the method/constructor is expecting
* @param suppliedArgTypes the array of types that are being supplied at the point of
* invocation
* @param suppliedArgTypes the array of types that are being supplied at the point of invocation
* @param typeConverter a registered type converter
* @return a MatchInfo object indicating what kind of match it was or null if it was
* not a match
* @return a MatchInfo object indicating what kind of match it was or null if it was not a match
*/
static ArgumentsMatchInfo compareArguments(
List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
@ -59,7 +56,6 @@ public class ReflectionHelper { @@ -59,7 +56,6 @@ public class ReflectionHelper {
"Expected argument types and supplied argument types should be arrays of same length");
ArgsMatchKind match = ArgsMatchKind.EXACT;
List<Integer> argsRequiringConversion = null;
for (int i = 0; i < expectedArgTypes.size() && match != null; i++) {
TypeDescriptor suppliedArg = suppliedArgTypes.get(i);
TypeDescriptor expectedArg = expectedArgTypes.get(i);
@ -77,10 +73,6 @@ public class ReflectionHelper { @@ -77,10 +73,6 @@ public class ReflectionHelper {
}
}
else if (typeConverter.canConvert(suppliedArg, expectedArg)) {
if (argsRequiringConversion == null) {
argsRequiringConversion = new ArrayList<Integer>();
}
argsRequiringConversion.add(i);
match = ArgsMatchKind.REQUIRES_CONVERSION;
}
else {
@ -89,21 +81,7 @@ public class ReflectionHelper { @@ -89,21 +81,7 @@ public class ReflectionHelper {
}
}
}
if (match == null) {
return null;
}
else {
if (match == ArgsMatchKind.REQUIRES_CONVERSION) {
int[] argsArray = new int[argsRequiringConversion.size()];
for (int i = 0; i < argsRequiringConversion.size(); i++) {
argsArray[i] = argsRequiringConversion.get(i);
}
return new ArgumentsMatchInfo(match, argsArray);
}
else {
return new ArgumentsMatchInfo(match);
}
}
return (match != null ? new ArgumentsMatchInfo(match) : null);
}
/**
@ -111,25 +89,25 @@ public class ReflectionHelper { @@ -111,25 +89,25 @@ public class ReflectionHelper {
*/
public static int getTypeDifferenceWeight(List<TypeDescriptor> paramTypes, List<TypeDescriptor> argTypes) {
int result = 0;
for (int i = 0,max=paramTypes.size(); i < max; i++) {
TypeDescriptor argType = argTypes.get(i);
for (int i = 0; i < paramTypes.size(); i++) {
TypeDescriptor paramType = paramTypes.get(i);
TypeDescriptor argType = argTypes.get(i);
if (argType == null) {
if (paramType.isPrimitive()) {
return Integer.MAX_VALUE;
}
}
if (!ClassUtils.isAssignable(paramType.getClass(), argType.getClass())) {
return Integer.MAX_VALUE;
}
if (argType != null) {
else {
Class<?> paramTypeClazz = paramType.getType();
if (!ClassUtils.isAssignable(paramTypeClazz, argType.getType())) {
return Integer.MAX_VALUE;
}
if (paramTypeClazz.isPrimitive()) {
paramTypeClazz = Object.class;
}
Class<?> superClass = argType.getClass().getSuperclass();
Class<?> superClass = argType.getType().getSuperclass();
while (superClass != null) {
if (paramType.equals(superClass)) {
if (paramTypeClazz.equals(superClass)) {
result = result + 2;
superClass = null;
}
@ -167,7 +145,6 @@ public class ReflectionHelper { @@ -167,7 +145,6 @@ public class ReflectionHelper {
"Final expected argument should be array type (the varargs parameter)");
ArgsMatchKind match = ArgsMatchKind.EXACT;
List<Integer> argsRequiringConversion = null;
// Check up until the varargs argument:
@ -189,10 +166,6 @@ public class ReflectionHelper { @@ -189,10 +166,6 @@ public class ReflectionHelper {
}
}
else if (typeConverter.canConvert(suppliedArg, expectedArg)) {
if (argsRequiringConversion == null) {
argsRequiringConversion = new ArrayList<Integer>();
}
argsRequiringConversion.add(i);
match = ArgsMatchKind.REQUIRES_CONVERSION;
}
else {
@ -214,29 +187,26 @@ public class ReflectionHelper { @@ -214,29 +187,26 @@ public class ReflectionHelper {
// expected argument - that is a match, the caller has already built the array. Proceed with it.
}
else {
// Now... we have the final argument in the method we are checking as a match and we have 0 or more other
// arguments left to pass to it.
Class<?> varargsParameterType = expectedArgTypes.get(expectedArgTypes.size() - 1).getElementTypeDescriptor().getType();
// Now... we have the final argument in the method we are checking as a match and we have 0
// or more other arguments left to pass to it.
Class<?> varargsParamType = expectedArgTypes.get(expectedArgTypes.size() - 1).getElementTypeDescriptor().getType();
// All remaining parameters must be of this type or convertable to this type
for (int i = expectedArgTypes.size() - 1; i < suppliedArgTypes.size(); i++) {
TypeDescriptor suppliedArg = suppliedArgTypes.get(i);
if (suppliedArg == null) {
if (varargsParameterType.isPrimitive()) {
if (varargsParamType.isPrimitive()) {
match = null;
}
} else {
if (varargsParameterType != suppliedArg.getType()) {
if (ClassUtils.isAssignable(varargsParameterType, suppliedArg.getType())) {
}
else {
if (varargsParamType != suppliedArg.getType()) {
if (ClassUtils.isAssignable(varargsParamType, suppliedArg.getType())) {
if (match != ArgsMatchKind.REQUIRES_CONVERSION) {
match = ArgsMatchKind.CLOSE;
}
}
else if (typeConverter.canConvert(suppliedArg, TypeDescriptor.valueOf(varargsParameterType))) {
if (argsRequiringConversion == null) {
argsRequiringConversion = new ArrayList<Integer>();
}
argsRequiringConversion.add(i);
else if (typeConverter.canConvert(suppliedArg, TypeDescriptor.valueOf(varargsParamType))) {
match = ArgsMatchKind.REQUIRES_CONVERSION;
}
else {
@ -247,21 +217,7 @@ public class ReflectionHelper { @@ -247,21 +217,7 @@ public class ReflectionHelper {
}
}
if (match == null) {
return null;
}
else {
if (match == ArgsMatchKind.REQUIRES_CONVERSION) {
int[] argsArray = new int[argsRequiringConversion.size()];
for (int i = 0; i < argsRequiringConversion.size(); i++) {
argsArray[i] = argsRequiringConversion.get(i);
}
return new ArgumentsMatchInfo(match, argsArray);
}
else {
return new ArgumentsMatchInfo(match);
}
}
return (match != null ? new ArgumentsMatchInfo(match) : null);
}
/**
@ -271,19 +227,20 @@ public class ReflectionHelper { @@ -271,19 +227,20 @@ public class ReflectionHelper {
* @param converter the type converter to use for attempting conversions
* @param arguments the actual arguments that need conversion
* @param methodOrCtor the target Method or Constructor
* @param argumentsRequiringConversion details which of the input arguments for sure need conversion
* @param varargsPosition the known position of the varargs argument, if any
* @throws EvaluationException if a problem occurs during conversion
*/
static void convertArguments(TypeConverter converter, Object[] arguments, Object methodOrCtor,
int[] argumentsRequiringConversion, Integer varargsPosition) throws EvaluationException {
Integer varargsPosition) throws EvaluationException {
if (varargsPosition == null) {
for (int i = 0; i < arguments.length; i++) {
TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forMethodOrConstructor(methodOrCtor, i));
Object argument = arguments[i];
arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
}
} else {
}
else {
for (int i = 0; i < varargsPosition; i++) {
TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forMethodOrConstructor(methodOrCtor, i));
Object argument = arguments[i];
@ -294,7 +251,8 @@ public class ReflectionHelper { @@ -294,7 +251,8 @@ public class ReflectionHelper {
TypeDescriptor targetType = new TypeDescriptor(methodParam);
Object argument = arguments[varargsPosition];
arguments[varargsPosition] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
} else {
}
else {
TypeDescriptor targetType = TypeDescriptor.nested(methodParam, 1);
for (int i = varargsPosition; i < arguments.length; i++) {
Object argument = arguments[i];
@ -316,28 +274,31 @@ public class ReflectionHelper { @@ -316,28 +274,31 @@ public class ReflectionHelper {
* @param method the target Method
* @throws SpelEvaluationException if there is a problem with conversion
*/
public static void convertAllArguments(TypeConverter converter, Object[] arguments, Method method) throws SpelEvaluationException {
public static void convertAllArguments(TypeConverter converter, Object[] arguments, Method method)
throws SpelEvaluationException {
Integer varargsPosition = null;
if (method.isVarArgs()) {
Class<?>[] paramTypes = method.getParameterTypes();
varargsPosition = paramTypes.length - 1;
}
for (int argPosition = 0; argPosition < arguments.length; argPosition++) {
for (int argPos = 0; argPos < arguments.length; argPos++) {
TypeDescriptor targetType;
if (varargsPosition != null && argPosition >= varargsPosition) {
if (varargsPosition != null && argPos >= varargsPosition) {
MethodParameter methodParam = new MethodParameter(method, varargsPosition);
targetType = TypeDescriptor.nested(methodParam, 1);
}
else {
targetType = new TypeDescriptor(new MethodParameter(method, argPosition));
targetType = new TypeDescriptor(new MethodParameter(method, argPos));
}
try {
Object argument = arguments[argPosition];
Object argument = arguments[argPos];
if (argument != null && !targetType.getObjectType().isInstance(argument)) {
if (converter == null) {
throw new SpelEvaluationException(SpelMessage.TYPE_CONVERSION_ERROR, argument.getClass().getName(), targetType);
throw new SpelEvaluationException(
SpelMessage.TYPE_CONVERSION_ERROR, argument.getClass().getName(), targetType);
}
arguments[argPosition] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
arguments[argPos] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
}
}
catch (EvaluationException ex) {
@ -346,7 +307,8 @@ public class ReflectionHelper { @@ -346,7 +307,8 @@ public class ReflectionHelper {
throw (SpelEvaluationException)ex;
}
else {
throw new SpelEvaluationException(ex, SpelMessage.TYPE_CONVERSION_ERROR,arguments[argPosition].getClass().getName(), targetType);
throw new SpelEvaluationException(ex,
SpelMessage.TYPE_CONVERSION_ERROR,arguments[argPos].getClass().getName(), targetType);
}
}
}
@ -377,9 +339,8 @@ public class ReflectionHelper { @@ -377,9 +339,8 @@ public class ReflectionHelper {
// Create an array for the varargs arguments
Object[] newArgs = new Object[parameterCount];
for (int i = 0; i < newArgs.length - 1; i++) {
newArgs[i] = args[i];
}
System.arraycopy(args, 0, newArgs, 0, newArgs.length - 1);
// Now sort out the final argument, which is the varargs one. Before entering this
// method the arguments should have been converted to the box form of the required type.
Class<?> componentType = requiredParameterTypes[parameterCount-1].getComponentType();
@ -450,12 +411,9 @@ public class ReflectionHelper { @@ -450,12 +411,9 @@ public class ReflectionHelper {
}
}
else {
Object[] repackagedArguments = (Object[]) Array.newInstance(
componentType, arraySize);
Object[] repackagedArguments = (Object[]) Array.newInstance(componentType, arraySize);
// Copy all but the varargs arguments
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = args[parameterCount + i - 1];
}
System.arraycopy(args, parameterCount - 1, repackagedArguments, 0, arraySize);
newArgs[newArgs.length - 1] = repackagedArguments;
}
return newArgs;
@ -465,32 +423,28 @@ public class ReflectionHelper { @@ -465,32 +423,28 @@ public class ReflectionHelper {
public static enum ArgsMatchKind {
// An exact match is where the parameter types exactly match what the method/constructor being invoked is expecting
/** An exact match is where the parameter types exactly match what the method/constructor being invoked is expecting */
EXACT,
// A close match is where the parameter types either exactly match or are assignment compatible with the method/constructor being invoked
/** A close match is where the parameter types either exactly match or are assignment compatible with the method/constructor being invoked */
CLOSE,
// A conversion match is where the type converter must be used to transform some of the parameter types
/** A conversion match is where the type converter must be used to transform some of the parameter types */
REQUIRES_CONVERSION
}
/**
* An instance of ArgumentsMatchInfo describes what kind of match was achieved between two sets of arguments - the set that a
* method/constructor is expecting and the set that are being supplied at the point of invocation. If the kind
* indicates that conversion is required for some of the arguments then the arguments that require conversion are
* listed in the argsRequiringConversion array.
* An instance of ArgumentsMatchInfo describes what kind of match was achieved between two sets of arguments -
* the set that a method/constructor is expecting and the set that are being supplied at the point of invocation.
* If the kind indicates that conversion is required for some of the arguments then the arguments that require
* conversion are listed in the argsRequiringConversion array.
*/
public static class ArgumentsMatchInfo {
public final ArgsMatchKind kind;
public int[] argsRequiringConversion;
ArgumentsMatchInfo(ArgsMatchKind kind, int[] integers) {
this.kind = kind;
this.argsRequiringConversion = integers;
}
ArgumentsMatchInfo(ArgsMatchKind kind) {
this.kind = kind;
}
@ -509,19 +463,7 @@ public class ReflectionHelper { @@ -509,19 +463,7 @@ public class ReflectionHelper {
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("ArgumentMatch: ").append(this.kind);
if (this.argsRequiringConversion != null) {
sb.append(" (argsForConversion:");
for (int i = 0; i < this.argsRequiringConversion.length;i++) {
if (i > 0) {
sb.append(",");
}
sb.append(this.argsRequiringConversion[i]);
}
sb.append(")");
}
return sb.toString();
return "ArgumentMatchInfo: " + this.kind;
}
}

10
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorExecutor.java
Unescape View File

@ -38,12 +38,8 @@ class ReflectiveConstructorExecutor implements ConstructorExecutor { @@ -38,12 +38,8 @@ class ReflectiveConstructorExecutor implements ConstructorExecutor {
private final Integer varargsPosition;
// When the constructor was found, we will have determined if arguments need to be converted for it
// to be invoked. Conversion won't be cheap so let's only do it if necessary.
private final int[] argsRequiringConversion;
public ReflectiveConstructorExecutor(Constructor<?> ctor, int[] argsRequiringConversion) {
public ReflectiveConstructorExecutor(Constructor<?> ctor) {
this.ctor = ctor;
if (ctor.isVarArgs()) {
Class<?>[] paramTypes = ctor.getParameterTypes();
@ -52,15 +48,13 @@ class ReflectiveConstructorExecutor implements ConstructorExecutor { @@ -52,15 +48,13 @@ class ReflectiveConstructorExecutor implements ConstructorExecutor {
else {
this.varargsPosition = null;
}
this.argsRequiringConversion = argsRequiringConversion;
}
@Override
public TypedValue execute(EvaluationContext context, Object... arguments) throws AccessException {
try {
if (arguments != null) {
ReflectionHelper.convertArguments(context.getTypeConverter(), arguments,
this.ctor, this.argsRequiringConversion, this.varargsPosition);
ReflectionHelper.convertArguments(context.getTypeConverter(), arguments, this.ctor, this.varargsPosition);
}
if (this.ctor.isVarArgs()) {
arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(this.ctor.getParameterTypes(), arguments);

24
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorResolver.java
Unescape View File

@ -71,8 +71,6 @@ public class ReflectiveConstructorResolver implements ConstructorResolver { @@ -71,8 +71,6 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
});
Constructor<?> closeMatch = null;
int[] argsToConvert = null;
Constructor<?> matchRequiringConversion = null;
for (Constructor<?> ctor : ctors) {
Class<?>[] paramTypes = ctor.getParameterTypes();
@ -81,7 +79,7 @@ public class ReflectiveConstructorResolver implements ConstructorResolver { @@ -81,7 +79,7 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
paramDescriptors.add(new TypeDescriptor(new MethodParameter(ctor, i)));
}
ReflectionHelper.ArgumentsMatchInfo matchInfo = null;
if (ctor.isVarArgs() && argumentTypes.size() >= (paramTypes.length - 1)) {
if (ctor.isVarArgs() && argumentTypes.size() >= paramTypes.length - 1) {
// *sigh* complicated
// Basically.. we have to have all parameters match up until the varargs one, then the rest of what is
// being provided should be
@ -96,26 +94,16 @@ public class ReflectiveConstructorResolver implements ConstructorResolver { @@ -96,26 +94,16 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
}
if (matchInfo != null) {
if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.EXACT) {
return new ReflectiveConstructorExecutor(ctor, null);
return new ReflectiveConstructorExecutor(ctor);
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.CLOSE) {
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.CLOSE ||
matchInfo.kind == ReflectionHelper.ArgsMatchKind.REQUIRES_CONVERSION) {
closeMatch = ctor;
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.REQUIRES_CONVERSION) {
argsToConvert = matchInfo.argsRequiringConversion;
matchRequiringConversion = ctor;
}
}
}
if (closeMatch != null) {
return new ReflectiveConstructorExecutor(closeMatch, null);
}
else if (matchRequiringConversion != null) {
return new ReflectiveConstructorExecutor(matchRequiringConversion, argsToConvert);
}
else {
return null;
}
return (closeMatch != null ? new ReflectiveConstructorExecutor(closeMatch) : null);
}
catch (EvaluationException ex) {
throw new AccessException("Failed to resolve constructor", ex);

17
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodExecutor.java
Unescape View File

@ -37,21 +37,16 @@ class ReflectiveMethodExecutor implements MethodExecutor { @@ -37,21 +37,16 @@ class ReflectiveMethodExecutor implements MethodExecutor {
private final Integer varargsPosition;
// When the method was found, we will have determined if arguments need to be converted for it
// to be invoked. Conversion won't be cheap so let's only do it if necessary.
private final int[] argsRequiringConversion;
public ReflectiveMethodExecutor(Method theMethod, int[] argumentsRequiringConversion) {
this.method = theMethod;
if (theMethod.isVarArgs()) {
Class<?>[] paramTypes = theMethod.getParameterTypes();
public ReflectiveMethodExecutor(Method method) {
this.method = method;
if (method.isVarArgs()) {
Class<?>[] paramTypes = method.getParameterTypes();
this.varargsPosition = paramTypes.length - 1;
}
else {
this.varargsPosition = null;
}
this.argsRequiringConversion = argumentsRequiringConversion;
}
@ -59,9 +54,7 @@ class ReflectiveMethodExecutor implements MethodExecutor { @@ -59,9 +54,7 @@ class ReflectiveMethodExecutor implements MethodExecutor {
public TypedValue execute(EvaluationContext context, Object target, Object... arguments) throws AccessException {
try {
if (arguments != null) {
ReflectionHelper.convertArguments(
context.getTypeConverter(), arguments, this.method,
this.argsRequiringConversion, this.varargsPosition);
ReflectionHelper.convertArguments(context.getTypeConverter(), arguments, this.method, this.varargsPosition);
}
if (this.method.isVarArgs()) {
arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(this.method.getParameterTypes(), arguments);

13
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodResolver.java
Unescape View File

@ -141,12 +141,12 @@ public class ReflectiveMethodResolver implements MethodResolver { @@ -141,12 +141,12 @@ public class ReflectiveMethodResolver implements MethodResolver {
matchInfo = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
}
else if (paramTypes.length == argumentTypes.size()) {
// name and parameter number match, check the arguments
// Name and parameter number match, check the arguments
matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
}
if (matchInfo != null) {
if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.EXACT) {
return new ReflectiveMethodExecutor(method, null);
return new ReflectiveMethodExecutor(method);
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.CLOSE) {
if (!this.useDistance) {
@ -154,8 +154,8 @@ public class ReflectiveMethodResolver implements MethodResolver { @@ -154,8 +154,8 @@ public class ReflectiveMethodResolver implements MethodResolver {
}
else {
int matchDistance = ReflectionHelper.getTypeDifferenceWeight(paramDescriptors, argumentTypes);
if (matchDistance<closeMatchDistance) {
// this is a better match
if (matchDistance < closeMatchDistance) {
// This is a better match...
closeMatchDistance = matchDistance;
closeMatch = method;
}
@ -165,20 +165,19 @@ public class ReflectiveMethodResolver implements MethodResolver { @@ -165,20 +165,19 @@ public class ReflectiveMethodResolver implements MethodResolver {
if (matchRequiringConversion != null) {
multipleOptions = true;
}
argsToConvert = matchInfo.argsRequiringConversion;
matchRequiringConversion = method;
}
}
}
}
if (closeMatch != null) {
return new ReflectiveMethodExecutor(closeMatch, null);
return new ReflectiveMethodExecutor(closeMatch);
}
else if (matchRequiringConversion != null) {
if (multipleOptions) {
throw new SpelEvaluationException(SpelMessage.MULTIPLE_POSSIBLE_METHODS, name);
}
return new ReflectiveMethodExecutor(matchRequiringConversion, argsToConvert);
return new ReflectiveMethodExecutor(matchRequiringConversion);
}
else {
return null;

188
spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java
Unescape View File

@ -1,5 +1,5 @@ @@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -16,13 +16,6 @@ @@ -16,13 +16,6 @@
package org.springframework.expression.spel.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Method;
@ -30,6 +23,7 @@ import java.util.ArrayList; @@ -30,6 +23,7 @@ import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ParseException;
@ -43,6 +37,8 @@ import org.springframework.expression.spel.ast.FormatHelper; @@ -43,6 +37,8 @@ import org.springframework.expression.spel.ast.FormatHelper;
import org.springframework.expression.spel.standard.SpelExpression;
import org.springframework.expression.spel.support.ReflectionHelper.ArgsMatchKind;
import static org.junit.Assert.*;
/**
* Tests for any helper code.
*
@ -63,7 +59,7 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -63,7 +59,7 @@ public class ReflectionHelperTests extends ExpressionTestCase {
@Test
public void testFormatHelperForMethod() {
assertEquals("foo(java.lang.String)",FormatHelper.formatMethodForMessage("foo", String.class));
assertEquals("goo(java.lang.String,int[])",FormatHelper.formatMethodForMessage("goo", String.class,new int[1].getClass()));
assertEquals("goo(java.lang.String,int[])",FormatHelper.formatMethodForMessage("goo", String.class, new int[1].getClass()));
assertEquals("boo()",FormatHelper.formatMethodForMessage("boo"));
}
*/
@ -95,8 +91,8 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -95,8 +91,8 @@ public class ReflectionHelperTests extends ExpressionTestCase {
// CompoundExpression value:2
// IntLiteral value:2
// ===> Expression '3+4+5+6+7-2' - AST end
assertTrue(s.indexOf("===> Expression '3+4+5+6+7-2' - AST start")!=-1);
assertTrue(s.indexOf(" OpPlus value:((((3 + 4) + 5) + 6) + 7) #children:2")!=-1);
assertTrue(s.contains("===> Expression '3+4+5+6+7-2' - AST start"));
assertTrue(s.contains(" OpPlus value:((((3 + 4) + 5) + 6) + 7) #children:2"));
}
@Test
@ -108,44 +104,44 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -108,44 +104,44 @@ public class ReflectionHelperTests extends ExpressionTestCase {
@Test
public void testReflectionHelperCompareArguments_ExactMatching() {
StandardTypeConverter typeConverter = new StandardTypeConverter();
StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(String) with (String) is exact match
checkMatch(new Class[]{String.class},new Class[]{String.class},typeConverter,ArgsMatchKind.EXACT);
checkMatch(new Class[] {String.class}, new Class[] {String.class}, tc,ArgsMatchKind.EXACT);
// Calling foo(String,Integer) with (String,Integer) is exact match
checkMatch(new Class[]{String.class,Integer.class},new Class[]{String.class,Integer.class},typeConverter,ArgsMatchKind.EXACT);
checkMatch(new Class[] {String.class, Integer.class}, new Class[] {String.class, Integer.class}, tc, ArgsMatchKind.EXACT);
}
@Test
public void testReflectionHelperCompareArguments_CloseMatching() {
StandardTypeConverter typeConverter = new StandardTypeConverter();
StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(List) with (ArrayList) is close match (no conversion required)
checkMatch(new Class[]{ArrayList.class},new Class[]{List.class},typeConverter,ArgsMatchKind.CLOSE);
checkMatch(new Class[] {ArrayList.class}, new Class[] {List.class}, tc, ArgsMatchKind.CLOSE);
// Passing (Sub,String) on call to foo(Super,String) is close match
checkMatch(new Class[]{Sub.class,String.class},new Class[]{Super.class,String.class},typeConverter,ArgsMatchKind.CLOSE);
checkMatch(new Class[] {Sub.class, String.class}, new Class[] {Super.class, String.class}, tc, ArgsMatchKind.CLOSE);
// Passing (String,Sub) on call to foo(String,Super) is close match
checkMatch(new Class[]{String.class,Sub.class},new Class[]{String.class,Super.class},typeConverter,ArgsMatchKind.CLOSE);
checkMatch(new Class[] {String.class, Sub.class}, new Class[] {String.class, Super.class}, tc, ArgsMatchKind.CLOSE);
}
@Test
public void testReflectionHelperCompareArguments_RequiresConversionMatching() {
StandardTypeConverter typeConverter = new StandardTypeConverter();
StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(String,int) with (String,Integer) requires boxing conversion of argument one
checkMatch(new Class[]{String.class,Integer.TYPE},new Class[]{String.class,Integer.class},typeConverter,ArgsMatchKind.CLOSE,1);
checkMatch(new Class[] {String.class, Integer.TYPE}, new Class[] {String.class,Integer.class},tc, ArgsMatchKind.CLOSE);
// Passing (int,String) on call to foo(Integer,String) requires boxing conversion of argument zero
checkMatch(new Class[]{Integer.TYPE,String.class},new Class[]{Integer.class, String.class},typeConverter,ArgsMatchKind.CLOSE,0);
checkMatch(new Class[] {Integer.TYPE, String.class}, new Class[] {Integer.class, String.class},tc, ArgsMatchKind.CLOSE);
// Passing (int,Sub) on call to foo(Integer,Super) requires boxing conversion of argument zero
checkMatch(new Class[]{Integer.TYPE,Sub.class},new Class[]{Integer.class, Super.class},typeConverter,ArgsMatchKind.CLOSE,0);
checkMatch(new Class[] {Integer.TYPE, Sub.class}, new Class[] {Integer.class, Super.class}, tc, ArgsMatchKind.CLOSE);
// Passing (int,Sub,boolean) on call to foo(Integer,Super,Boolean) requires boxing conversion of arguments zero and two
// TODO checkMatch(new Class[]{Integer.TYPE,Sub.class,Boolean.TYPE},new Class[]{Integer.class, Super.class,Boolean.class},typeConverter,ArgsMatchKind.REQUIRES_CONVERSION,0,2);
// TODO checkMatch(new Class[] {Integer.TYPE, Sub.class, Boolean.TYPE}, new Class[] {Integer.class, Super.class, Boolean.class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
}
@Test
@ -153,7 +149,7 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -153,7 +149,7 @@ public class ReflectionHelperTests extends ExpressionTestCase {
StandardTypeConverter typeConverter = new StandardTypeConverter();
// Passing (Super,String) on call to foo(Sub,String) is not a match
checkMatch(new Class[]{Super.class,String.class},new Class[]{Sub.class,String.class},typeConverter,null);
checkMatch(new Class[] {Super.class,String.class}, new Class[] {Sub.class,String.class},typeConverter,null);
}
@Test
@ -163,49 +159,49 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -163,49 +159,49 @@ public class ReflectionHelperTests extends ExpressionTestCase {
Class<?> integerArrayClass = new Integer[0].getClass();
// Passing (String[]) on call to (String[]) is exact match
checkMatch2(new Class[]{stringArrayClass},new Class[]{stringArrayClass},tc,ArgsMatchKind.EXACT);
checkMatch2(new Class[] {stringArrayClass}, new Class[] {stringArrayClass}, tc, ArgsMatchKind.EXACT);
// Passing (Integer, String[]) on call to (Integer, String[]) is exact match
checkMatch2(new Class[]{Integer.class,stringArrayClass},new Class[]{Integer.class,stringArrayClass},tc,ArgsMatchKind.EXACT);
checkMatch2(new Class[] {Integer.class, stringArrayClass}, new Class[] {Integer.class, stringArrayClass}, tc, ArgsMatchKind.EXACT);
// Passing (String, Integer, String[]) on call to (String, String, String[]) is exact match
checkMatch2(new Class[]{String.class,Integer.class,stringArrayClass},new Class[]{String.class,Integer.class,stringArrayClass},tc,ArgsMatchKind.EXACT);
checkMatch2(new Class[] {String.class, Integer.class, stringArrayClass}, new Class[] {String.class,Integer.class, stringArrayClass}, tc, ArgsMatchKind.EXACT);
// Passing (Sub, String[]) on call to (Super, String[]) is exact match
checkMatch2(new Class[]{Sub.class,stringArrayClass},new Class[]{Super.class,stringArrayClass},tc,ArgsMatchKind.CLOSE);
checkMatch2(new Class[] {Sub.class, stringArrayClass}, new Class[] {Super.class,stringArrayClass}, tc, ArgsMatchKind.CLOSE);
// Passing (Integer, String[]) on call to (String, String[]) is exact match
checkMatch2(new Class[]{Integer.class,stringArrayClass},new Class[]{String.class,stringArrayClass},tc,ArgsMatchKind.REQUIRES_CONVERSION,0);
checkMatch2(new Class[] {Integer.class, stringArrayClass}, new Class[] {String.class, stringArrayClass}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
// Passing (Integer, Sub, String[]) on call to (String, Super, String[]) is exact match
checkMatch2(new Class[]{Integer.class,Sub.class,String[].class},new Class[]{String.class,Super.class,String[].class},tc,ArgsMatchKind.REQUIRES_CONVERSION,0);
checkMatch2(new Class[] {Integer.class, Sub.class, String[].class}, new Class[] {String.class,Super .class, String[].class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
// Passing (String) on call to (String[]) is exact match
checkMatch2(new Class[]{String.class},new Class[]{stringArrayClass},tc,ArgsMatchKind.EXACT);
checkMatch2(new Class[] {String.class}, new Class[] {stringArrayClass}, tc, ArgsMatchKind.EXACT);
// Passing (Integer,String) on call to (Integer,String[]) is exact match
checkMatch2(new Class[]{Integer.class,String.class},new Class[]{Integer.class,stringArrayClass},tc,ArgsMatchKind.EXACT);
checkMatch2(new Class[] {Integer.class, String.class}, new Class[] {Integer.class, stringArrayClass}, tc, ArgsMatchKind.EXACT);
// Passing (String) on call to (Integer[]) is conversion match (String to Integer)
checkMatch2(new Class[]{String.class},new Class[]{integerArrayClass},tc,ArgsMatchKind.REQUIRES_CONVERSION,0);
checkMatch2(new Class[] {String.class}, new Class[] {integerArrayClass}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
// Passing (Sub) on call to (Super[]) is close match
checkMatch2(new Class[]{Sub.class},new Class[]{new Super[0].getClass()},tc,ArgsMatchKind.CLOSE);
checkMatch2(new Class[] {Sub.class}, new Class[] {new Super[0].getClass()}, tc, ArgsMatchKind.CLOSE);
// Passing (Super) on call to (Sub[]) is not a match
checkMatch2(new Class[]{Super.class},new Class[]{new Sub[0].getClass()},tc,null);
checkMatch2(new Class[] {Super.class}, new Class[] {new Sub[0].getClass()}, tc, null);
checkMatch2(new Class[]{Unconvertable.class,String.class},new Class[]{Sub.class,Super[].class},tc,null);
checkMatch2(new Class[] {Unconvertable.class, String.class}, new Class[] {Sub.class, Super[].class}, tc, null);
checkMatch2(new Class[]{Integer.class,Integer.class,String.class},new Class[]{String.class,String.class,Super[].class},tc,null);
checkMatch2(new Class[] {Integer.class, Integer.class, String.class}, new Class[] {String.class, String.class, Super[].class}, tc, null);
checkMatch2(new Class[]{Unconvertable.class,String.class},new Class[]{Sub.class,Super[].class},tc,null);
checkMatch2(new Class[] {Unconvertable.class, String.class}, new Class[] {Sub.class, Super[].class}, tc, null);
checkMatch2(new Class[]{Integer.class,Integer.class,String.class},new Class[]{String.class,String.class,Super[].class},tc,null);
checkMatch2(new Class[] {Integer.class, Integer.class, String.class}, new Class[] {String.class, String.class, Super[].class}, tc, null);
checkMatch2(new Class[]{Integer.class,Integer.class,Sub.class},new Class[]{String.class,String.class,Super[].class},tc,ArgsMatchKind.REQUIRES_CONVERSION,0,1);
checkMatch2(new Class[] {Integer.class, Integer.class, Sub.class}, new Class[] {String.class, String.class, Super[].class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
checkMatch2(new Class[]{Integer.class,Integer.class,Integer.class},new Class[]{Integer.class,String[].class},tc,ArgsMatchKind.REQUIRES_CONVERSION,1,2);
checkMatch2(new Class[] {Integer.class, Integer.class, Integer.class}, new Class[] {Integer.class, String[].class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
// what happens on (Integer,String) passed to (Integer[]) ?
}
@ -216,23 +212,23 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -216,23 +212,23 @@ public class ReflectionHelperTests extends ExpressionTestCase {
Method twoArg = TestInterface.class.getMethod("twoArg", String.class, String[].class);
// basic conversion int>String
Object[] args = new Object[]{3};
ReflectionHelper.convertArguments(tc, args, oneArg, new int[]{0}, null);
Object[] args = new Object[] {3};
ReflectionHelper.convertArguments(tc, args, oneArg, null);
checkArguments(args, "3");
// varargs but nothing to convert
args = new Object[]{3};
ReflectionHelper.convertArguments(tc, args, twoArg, new int[]{0}, 1);
args = new Object[] {3};
ReflectionHelper.convertArguments(tc, args, twoArg, 1);
checkArguments(args, "3");
// varargs with nothing needing conversion
args = new Object[]{3,"abc","abc"};
ReflectionHelper.convertArguments(tc, args, twoArg, new int[]{0,1,2}, 1);
args = new Object[] {3, "abc", "abc"};
ReflectionHelper.convertArguments(tc, args, twoArg, 1);
checkArguments(args, "3","abc","abc");
// varargs with conversion required
args = new Object[]{3,false,3.0d};
ReflectionHelper.convertArguments(tc, args, twoArg, new int[]{0,1,2}, 1);
args = new Object[] {3, false ,3.0d};
ReflectionHelper.convertArguments(tc, args, twoArg, 1);
checkArguments(args, "3","false","3.0");
}
@ -243,22 +239,22 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -243,22 +239,22 @@ public class ReflectionHelperTests extends ExpressionTestCase {
Method twoArg = TestInterface.class.getMethod("twoArg", String.class, String[].class);
// Simple conversion: int to string
Object[] args = new Object[]{3};
Object[] args = new Object[] {3};
ReflectionHelper.convertAllArguments(tc, args, oneArg);
checkArguments(args,"3");
// varargs conversion
args = new Object[]{3,false,3.0f};
args = new Object[] {3, false, 3.0f};
ReflectionHelper.convertAllArguments(tc, args, twoArg);
checkArguments(args,"3","false","3.0");
// varargs conversion but no varargs
args = new Object[]{3};
args = new Object[] {3};
ReflectionHelper.convertAllArguments(tc, args, twoArg);
checkArguments(args,"3");
// missing converter
args = new Object[]{3,false,3.0f};
args = new Object[] {3, false, 3.0f};
try {
ReflectionHelper.convertAllArguments(null, args, twoArg);
fail("Should have failed because no converter supplied");
@ -268,16 +264,16 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -268,16 +264,16 @@ public class ReflectionHelperTests extends ExpressionTestCase {
}
// null value
args = new Object[]{3,null,3.0f};
args = new Object[] {3, null, 3.0f};
ReflectionHelper.convertAllArguments(tc, args, twoArg);
checkArguments(args,"3",null,"3.0");
}
@Test
public void testSetupArguments() {
Object[] newArray = ReflectionHelper.setupArgumentsForVarargsInvocation(new Class[]{new String[0].getClass()},"a","b","c");
Object[] newArray = ReflectionHelper.setupArgumentsForVarargsInvocation(new Class[] {new String[0].getClass()},"a","b","c");
assertEquals(1,newArray.length);
assertEquals(1, newArray.length);
Object firstParam = newArray[0];
assertEquals(String.class,firstParam.getClass().getComponentType());
Object[] firstParamArray = (Object[])firstParam;
@ -362,13 +358,15 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -362,13 +358,15 @@ public class ReflectionHelperTests extends ExpressionTestCase {
try {
optA.canWrite(ctx, t, "property");
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
try {
optA.canWrite(ctx, t, "property2");
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
assertEquals("hello",optA.read(ctx, t, "property").getValue());
@ -377,13 +375,15 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -377,13 +375,15 @@ public class ReflectionHelperTests extends ExpressionTestCase {
try {
optA.getSpecificTargetClasses();
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
try {
optA.write(ctx,t,"property",null);
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
@ -393,13 +393,15 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -393,13 +393,15 @@ public class ReflectionHelperTests extends ExpressionTestCase {
try {
optA.canWrite(ctx, t, "field");
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
try {
optA.canWrite(ctx, t, "field2");
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
assertEquals(3,optA.read(ctx, t, "field").getValue());
@ -408,17 +410,17 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -408,17 +410,17 @@ public class ReflectionHelperTests extends ExpressionTestCase {
try {
optA.getSpecificTargetClasses();
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
try {
optA.write(ctx,t,"field",null);
fail();
} catch (UnsupportedOperationException uoe) {
}
catch (UnsupportedOperationException uoe) {
// success
}
}
@ -479,64 +481,52 @@ public class ReflectionHelperTests extends ExpressionTestCase { @@ -479,64 +481,52 @@ public class ReflectionHelperTests extends ExpressionTestCase {
/**
* Used to validate the match returned from a compareArguments call.
*/
private void checkMatch(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter,ArgsMatchKind expectedMatchKind,int... argsForConversion) {
private void checkMatch(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter, ArgsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo = ReflectionHelper.compareArguments(getTypeDescriptors(expectedTypes), getTypeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind==null) {
if (expectedMatchKind == null) {
assertNull("Did not expect them to match in any way", matchInfo);
} else {
}
else {
assertNotNull("Should not be a null match", matchInfo);
}
if (expectedMatchKind==ArgsMatchKind.EXACT) {
if (expectedMatchKind == ArgsMatchKind.EXACT) {
assertTrue(matchInfo.isExactMatch());
assertNull(matchInfo.argsRequiringConversion);
} else if (expectedMatchKind==ArgsMatchKind.CLOSE) {
}
else if (expectedMatchKind == ArgsMatchKind.CLOSE) {
assertTrue(matchInfo.isCloseMatch());
assertNull(matchInfo.argsRequiringConversion);
} else if (expectedMatchKind==ArgsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was "+matchInfo,matchInfo.isMatchRequiringConversion());
if (argsForConversion==null) {
fail("there are arguments that need conversion");
}
assertEquals("The array of args that need conversion is different length to that expected",argsForConversion.length, matchInfo.argsRequiringConversion.length);
for (int a=0;a<argsForConversion.length;a++) {
assertEquals(argsForConversion[a],matchInfo.argsRequiringConversion[a]);
}
}
else if (expectedMatchKind == ArgsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was " + matchInfo, matchInfo.isMatchRequiringConversion());
}
}
/**
* Used to validate the match returned from a compareArguments call.
*/
private void checkMatch2(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter,ArgsMatchKind expectedMatchKind,int... argsForConversion) {
private void checkMatch2(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter, ArgsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo = ReflectionHelper.compareArgumentsVarargs(getTypeDescriptors(expectedTypes), getTypeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind==null) {
if (expectedMatchKind == null) {
assertNull("Did not expect them to match in any way: "+matchInfo, matchInfo);
} else {
}
else {
assertNotNull("Should not be a null match", matchInfo);
}
if (expectedMatchKind==ArgsMatchKind.EXACT) {
if (expectedMatchKind == ArgsMatchKind.EXACT) {
assertTrue(matchInfo.isExactMatch());
assertNull(matchInfo.argsRequiringConversion);
} else if (expectedMatchKind==ArgsMatchKind.CLOSE) {
}
else if (expectedMatchKind == ArgsMatchKind.CLOSE) {
assertTrue(matchInfo.isCloseMatch());
assertNull(matchInfo.argsRequiringConversion);
} else if (expectedMatchKind==ArgsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was "+matchInfo,matchInfo.isMatchRequiringConversion());
if (argsForConversion==null) {
fail("there are arguments that need conversion");
}
assertEquals("The array of args that need conversion is different length to that expected",argsForConversion.length, matchInfo.argsRequiringConversion.length);
for (int a=0;a<argsForConversion.length;a++) {
assertEquals(argsForConversion[a],matchInfo.argsRequiringConversion[a]);
}
}
else if (expectedMatchKind == ArgsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was " + matchInfo, matchInfo.isMatchRequiringConversion());
}
}
private void checkArguments(Object[] args, Object... expected) {
assertEquals(expected.length,args.length);
for (int i=0;i<expected.length;i++) {
for (int i = 0; i < expected.length; i++) {
checkArgument(expected[i],args[i]);
}
}

Write Preview
Loading…
Cancel
Save