root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Turned ArgumentsMatchKind and ArgumentsMatchInfo to package-visible

This commit is contained in:
Juergen Hoeller 2014-01-15 15:28:20 +01:00
parent abff789b0f
commit 8da9e5466a
4 changed files with 72 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -55,7 +55,7 @@ public class ReflectionHelper {
Assert.isTrue(expectedArgTypes.size() == suppliedArgTypes.size(),
"Expected argument types and supplied argument types should be arrays of same length");
ArgsMatchKind match = ArgsMatchKind.EXACT;
ArgumentsMatchKind match = ArgumentsMatchKind.EXACT;
for (int i = 0; i < expectedArgTypes.size() && match != null; i++) {
TypeDescriptor suppliedArg = suppliedArgTypes.get(i);
TypeDescriptor expectedArg = expectedArgTypes.get(i);
@ -68,12 +68,12 @@ public class ReflectionHelper {
}
else {
if (suppliedArg.isAssignableTo(expectedArg)) {
if (match != ArgsMatchKind.REQUIRES_CONVERSION) {
match = ArgsMatchKind.CLOSE;
if (match != ArgumentsMatchKind.REQUIRES_CONVERSION) {
match = ArgumentsMatchKind.CLOSE;
}
}
else if (typeConverter.canConvert(suppliedArg, expectedArg)) {
match = ArgsMatchKind.REQUIRES_CONVERSION;
match = ArgumentsMatchKind.REQUIRES_CONVERSION;
}
else {
match = null;
@ -144,7 +144,7 @@ public class ReflectionHelper {
Assert.isTrue(expectedArgTypes.get(expectedArgTypes.size() - 1).isArray(),
"Final expected argument should be array type (the varargs parameter)");
ArgsMatchKind match = ArgsMatchKind.EXACT;
ArgumentsMatchKind match = ArgumentsMatchKind.EXACT;
// Check up until the varargs argument:
@ -161,12 +161,12 @@ public class ReflectionHelper {
else {
if (!expectedArg.equals(suppliedArg)) {
if (suppliedArg.isAssignableTo(expectedArg)) {
if (match != ArgsMatchKind.REQUIRES_CONVERSION) {
match = ArgsMatchKind.CLOSE;
if (match != ArgumentsMatchKind.REQUIRES_CONVERSION) {
match = ArgumentsMatchKind.CLOSE;
}
}
else if (typeConverter.canConvert(suppliedArg, expectedArg)) {
match = ArgsMatchKind.REQUIRES_CONVERSION;
match = ArgumentsMatchKind.REQUIRES_CONVERSION;
}
else {
match = null;
@ -202,12 +202,12 @@ public class ReflectionHelper {
else {
if (varargsParamType != suppliedArg.getType()) {
if (ClassUtils.isAssignable(varargsParamType, suppliedArg.getType())) {
if (match != ArgsMatchKind.REQUIRES_CONVERSION) {
match = ArgsMatchKind.CLOSE;
if (match != ArgumentsMatchKind.REQUIRES_CONVERSION) {
match = ArgumentsMatchKind.CLOSE;
}
}
else if (typeConverter.canConvert(suppliedArg, TypeDescriptor.valueOf(varargsParamType))) {
match = ArgsMatchKind.REQUIRES_CONVERSION;
match = ArgumentsMatchKind.REQUIRES_CONVERSION;
}
else {
match = null;
@ -331,8 +331,9 @@ public class ReflectionHelper {
// Check if repackaging is needed:
if (parameterCount != args.length ||
requiredParameterTypes[parameterCount - 1] !=
(args[argumentCount - 1] == null ? null : args[argumentCount - 1].getClass())) {
int arraySize = 0; // zero size array if nothing to pass as the varargs parameter
(args[argumentCount - 1] != null ? args[argumentCount - 1].getClass() : null)) {
int arraySize = 0; // zero size array if nothing to pass as the varargs parameter
if (argumentCount >= parameterCount) {
arraySize = argumentCount - (parameterCount - 1);
}
@ -341,93 +342,26 @@ public class ReflectionHelper {
Object[] newArgs = new Object[parameterCount];
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();
if (componentType.isPrimitive()) {
if (componentType == Integer.TYPE) {
int[] repackagedArguments = (int[]) Array.newInstance(componentType,
arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Integer) args[parameterCount + i - 1]).intValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Float.TYPE) {
float[] repackagedArguments = (float[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Float) args[parameterCount + i - 1]).floatValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Double.TYPE) {
double[] repackagedArguments = (double[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Double) args[parameterCount + i - 1]).doubleValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Short.TYPE) {
short[] repackagedArguments = (short[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Short) args[parameterCount + i - 1]).shortValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Character.TYPE) {
char[] repackagedArguments = (char[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Character) args[parameterCount + i - 1]).charValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Byte.TYPE) {
byte[] repackagedArguments = (byte[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Byte) args[parameterCount + i - 1]).byteValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Boolean.TYPE) {
boolean[] repackagedArguments = (boolean[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Boolean) args[parameterCount + i - 1]).booleanValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
else if (componentType == Long.TYPE) {
long[] repackagedArguments = (long[]) Array.newInstance(
componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
repackagedArguments[i] = ((Long) args[parameterCount + i - 1]).longValue();
}
newArgs[newArgs.length - 1] = repackagedArguments;
}
}
else {
Object[] repackagedArguments = (Object[]) Array.newInstance(componentType, arraySize);
// Copy all but the varargs arguments
System.arraycopy(args, parameterCount - 1, repackagedArguments, 0, arraySize);
newArgs[newArgs.length - 1] = repackagedArguments;
// 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();
Object repackagedArgs = Array.newInstance(componentType, arraySize);
for (int i = 0; i < arraySize; i++) {
Array.set(repackagedArgs, i, args[parameterCount - 1 + i]);
}
newArgs[newArgs.length - 1] = repackagedArgs;
return newArgs;
}
return args;
}
public static enum ArgsMatchKind {
static enum ArgumentsMatchKind {
/** 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 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 */
CLOSE,
/** A conversion match is where the type converter must be used to transform some of the parameter types */
@ -441,24 +375,24 @@ public class ReflectionHelper {
* 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 {
static class ArgumentsMatchInfo {
public final ArgsMatchKind kind;
private final ArgumentsMatchKind kind;
ArgumentsMatchInfo(ArgsMatchKind kind) {
ArgumentsMatchInfo(ArgumentsMatchKind kind) {
this.kind = kind;
}
public boolean isExactMatch() {
return (this.kind == ArgsMatchKind.EXACT);
return (this.kind == ArgumentsMatchKind.EXACT);
}
public boolean isCloseMatch() {
return (this.kind == ArgsMatchKind.CLOSE);
return (this.kind == ArgumentsMatchKind.CLOSE);
}
public boolean isMatchRequiringConversion() {
return (this.kind == ArgsMatchKind.REQUIRES_CONVERSION);
return (this.kind == ArgumentsMatchKind.REQUIRES_CONVERSION);
}
@Override

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

@ -32,8 +32,7 @@ import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypeConverter;
/**
* A constructor resolver that uses reflection to locate the constructor that should be
* invoked
* A constructor resolver that uses reflection to locate the constructor that should be invoked.
*
* @author Andy Clement
* @author Juergen Hoeller
@ -44,12 +43,10 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
/**
* Locate a constructor on the type. There are three kinds of match that might occur:
* <ol>
* <li>An exact match where the types of the arguments match the types of the
* constructor
* <li>An in-exact match where the types we are looking for are subtypes of those
* defined on the constructor
* <li>A match where we are able to convert the arguments into those expected by the
* constructor, according to the registered type converter.
* <li>An exact match where the types of the arguments match the types of the constructor
* <li>An in-exact match where the types we are looking for are subtypes of those defined on the constructor
* <li>A match where we are able to convert the arguments into those expected by the constructor, according to the
* registered type converter.
* </ol>
*/
@Override
@ -93,11 +90,10 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
}
if (matchInfo != null) {
if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.EXACT) {
if (matchInfo.isExactMatch()) {
return new ReflectiveConstructorExecutor(ctor);
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.CLOSE ||
matchInfo.kind == ReflectionHelper.ArgsMatchKind.REQUIRES_CONVERSION) {
else if (matchInfo.isCloseMatch() || matchInfo.isMatchRequiringConversion()) {
closeMatch = ctor;
}
}

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

@ -42,8 +42,8 @@ import org.springframework.expression.spel.SpelEvaluationException;
import org.springframework.expression.spel.SpelMessage;
/**
* Reflection-based {@link MethodResolver} used by default in
* {@link StandardEvaluationContext} unless explicit method resolvers have been specified.
* Reflection-based {@link MethodResolver} used by default in {@link StandardEvaluationContext}
* unless explicit method resolvers have been specified.
*
* @author Andy Clement
* @author Juergen Hoeller
@ -124,7 +124,6 @@ public class ReflectiveMethodResolver implements MethodResolver {
Method closeMatch = null;
int closeMatchDistance = Integer.MAX_VALUE;
int[] argsToConvert = null;
Method matchRequiringConversion = null;
boolean multipleOptions = false;
@ -145,10 +144,10 @@ public class ReflectiveMethodResolver implements MethodResolver {
matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
}
if (matchInfo != null) {
if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.EXACT) {
if (matchInfo.isExactMatch()) {
return new ReflectiveMethodExecutor(method);
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.CLOSE) {
else if (matchInfo.isCloseMatch()) {
if (!this.useDistance) {
closeMatch = method;
}
@ -161,7 +160,7 @@ public class ReflectiveMethodResolver implements MethodResolver {
}
}
}
else if (matchInfo.kind == ReflectionHelper.ArgsMatchKind.REQUIRES_CONVERSION) {
else if (matchInfo.isMatchRequiringConversion()) {
if (matchRequiringConversion != null) {
multipleOptions = true;
}

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

@ -35,7 +35,7 @@ import org.springframework.expression.spel.SpelMessage;
import org.springframework.expression.spel.SpelUtilities;
import org.springframework.expression.spel.ast.FormatHelper;
import org.springframework.expression.spel.standard.SpelExpression;
import org.springframework.expression.spel.support.ReflectionHelper.ArgsMatchKind;
import org.springframework.expression.spel.support.ReflectionHelper.ArgumentsMatchKind;
import static org.junit.Assert.*;
@ -107,10 +107,10 @@ public class ReflectionHelperTests extends ExpressionTestCase {
StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(String) with (String) is exact match
checkMatch(new Class[] {String.class}, new Class[] {String.class}, tc,ArgsMatchKind.EXACT);
checkMatch(new Class[] {String.class}, new Class[] {String.class}, tc, ReflectionHelper.ArgumentsMatchKind.EXACT);
// Calling foo(String,Integer) with (String,Integer) is exact match
checkMatch(new Class[] {String.class, Integer.class}, new Class[] {String.class, Integer.class}, tc, ArgsMatchKind.EXACT);
checkMatch(new Class[] {String.class, Integer.class}, new Class[] {String.class, Integer.class}, tc, ArgumentsMatchKind.EXACT);
}
@Test
@ -118,13 +118,13 @@ public class ReflectionHelperTests extends ExpressionTestCase {
StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(List) with (ArrayList) is close match (no conversion required)
checkMatch(new Class[] {ArrayList.class}, new Class[] {List.class}, tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {ArrayList.class}, new Class[] {List.class}, tc, ArgumentsMatchKind.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}, tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {Sub.class, String.class}, new Class[] {Super.class, String.class}, tc, ArgumentsMatchKind.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}, tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {String.class, Sub.class}, new Class[] {String.class, Super.class}, tc, ArgumentsMatchKind.CLOSE);
}
@Test
@ -132,13 +132,13 @@ public class ReflectionHelperTests extends ExpressionTestCase {
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},tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {String.class, Integer.TYPE}, new Class[] {String.class,Integer.class},tc, ArgumentsMatchKind.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},tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {Integer.TYPE, String.class}, new Class[] {Integer.class, String.class},tc, ArgumentsMatchKind.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}, tc, ArgsMatchKind.CLOSE);
checkMatch(new Class[] {Integer.TYPE, Sub.class}, new Class[] {Integer.class, Super.class}, tc, ArgumentsMatchKind.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}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
@ -159,34 +159,34 @@ 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, ArgumentsMatchKind.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, ArgumentsMatchKind.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, ArgumentsMatchKind.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, ArgumentsMatchKind.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);
checkMatch2(new Class[] {Integer.class, stringArrayClass}, new Class[] {String.class, stringArrayClass}, tc, ArgumentsMatchKind.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);
checkMatch2(new Class[] {Integer.class, Sub.class, String[].class}, new Class[] {String.class,Super .class, String[].class}, tc, ArgumentsMatchKind.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, ArgumentsMatchKind.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, ArgumentsMatchKind.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);
checkMatch2(new Class[] {String.class}, new Class[] {integerArrayClass}, tc, ArgumentsMatchKind.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, ArgumentsMatchKind.CLOSE);
// Passing (Super) on call to (Sub[]) is not a match
checkMatch2(new Class[] {Super.class}, new Class[] {new Sub[0].getClass()}, tc, null);
@ -199,9 +199,9 @@ public class ReflectionHelperTests extends ExpressionTestCase {
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);
checkMatch2(new Class[] {Integer.class, Integer.class, Sub.class}, new Class[] {String.class, String.class, Super[].class}, tc, ArgumentsMatchKind.REQUIRES_CONVERSION);
checkMatch2(new Class[] {Integer.class, Integer.class, Integer.class}, new Class[] {Integer.class, String[].class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
checkMatch2(new Class[] {Integer.class, Integer.class, Integer.class}, new Class[] {Integer.class, String[].class}, tc, ArgumentsMatchKind.REQUIRES_CONVERSION);
// what happens on (Integer,String) passed to (Integer[]) ?
}
@ -481,7 +481,7 @@ 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) {
private void checkMatch(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter, ArgumentsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo = ReflectionHelper.compareArguments(getTypeDescriptors(expectedTypes), getTypeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind == null) {
assertNull("Did not expect them to match in any way", matchInfo);
@ -490,13 +490,13 @@ public class ReflectionHelperTests extends ExpressionTestCase {
assertNotNull("Should not be a null match", matchInfo);
}
if (expectedMatchKind == ArgsMatchKind.EXACT) {
if (expectedMatchKind == ArgumentsMatchKind.EXACT) {
assertTrue(matchInfo.isExactMatch());
}
else if (expectedMatchKind == ArgsMatchKind.CLOSE) {
else if (expectedMatchKind == ArgumentsMatchKind.CLOSE) {
assertTrue(matchInfo.isCloseMatch());
}
else if (expectedMatchKind == ArgsMatchKind.REQUIRES_CONVERSION) {
else if (expectedMatchKind == ArgumentsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was " + matchInfo, matchInfo.isMatchRequiringConversion());
}
}
@ -504,22 +504,22 @@ public class ReflectionHelperTests extends ExpressionTestCase {
/**
* Used to validate the match returned from a compareArguments call.
*/
private void checkMatch2(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter, ArgsMatchKind expectedMatchKind) {
private void checkMatch2(Class[] inputTypes, Class[] expectedTypes, StandardTypeConverter typeConverter, ArgumentsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo = ReflectionHelper.compareArgumentsVarargs(getTypeDescriptors(expectedTypes), getTypeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind == null) {
assertNull("Did not expect them to match in any way: "+matchInfo, matchInfo);
assertNull("Did not expect them to match in any way: " + matchInfo, matchInfo);
}
else {
assertNotNull("Should not be a null match", matchInfo);
}
if (expectedMatchKind == ArgsMatchKind.EXACT) {
if (expectedMatchKind == ArgumentsMatchKind.EXACT) {
assertTrue(matchInfo.isExactMatch());
}
else if (expectedMatchKind == ArgsMatchKind.CLOSE) {
else if (expectedMatchKind == ArgumentsMatchKind.CLOSE) {
assertTrue(matchInfo.isCloseMatch());
}
else if (expectedMatchKind == ArgsMatchKind.REQUIRES_CONVERSION) {
else if (expectedMatchKind == ArgumentsMatchKind.REQUIRES_CONVERSION) {
assertTrue("expected to be a match requiring conversion, but was " + matchInfo, matchInfo.isMatchRequiringConversion());
}
}