1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
package junitparams.internal;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import org.junit.runner.Description;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;
import junitparams.converters.ConversionFailedException;
import junitparams.converters.ConvertParam;
import junitparams.converters.ParamAnnotation;
import junitparams.converters.ParamConverter;
/**
* JUnit invoker for parameterised test methods
*
* @author Pawel Lipinski
*/
public class InvokeParameterisedMethod extends Statement {
private final Object[] params;
private final FrameworkMethod testMethod;
private final Object testClass;
private final String uniqueMethodId;
public InvokeParameterisedMethod(FrameworkMethod testMethod, Object testClass, Object params, int paramSetIdx) {
this.testMethod = testMethod;
this.testClass = testClass;
this.uniqueMethodId = Utils.uniqueMethodId(paramSetIdx - 1, params, testMethod.getName());
try {
if (params instanceof String)
this.params = castParamsFromString((String) params);
else {
this.params = castParamsFromObjects(params);
}
} catch (ConversionFailedException e) {
throw new RuntimeException(e);
}
}
private Object[] castParamsFromString(String params) throws ConversionFailedException {
Object[] columns = null;
try {
columns = Utils.splitAtCommaOrPipe(params);
columns = castParamsUsingConverters(columns);
} catch (RuntimeException e) {
new IllegalArgumentException("Cannot parse parameters. Did you use ',' or '|' as column separator? "
+ params, e).printStackTrace();
}
return columns;
}
private Object[] castParamsFromObjects(Object params) throws ConversionFailedException {
Object[] paramset = Utils.safelyCastParamsToArray(params);
try {
return castParamsUsingConverters(paramset);
} catch (ConversionFailedException e) {
throw e;
} catch (Exception e) {
Class<?>[] typesOfParameters = createArrayOfTypesOf(paramset);
Object resultParam = createObjectOfExpectedTypeBasedOnParams(paramset, typesOfParameters);
return new Object[]{resultParam};
}
}
private Object createObjectOfExpectedTypeBasedOnParams(Object[] paramset, Class<?>[] typesOfParameters) {
Object resultParam;
try {
if (testMethod.getMethod().getParameterTypes()[0].isArray()) {
resultParam = Array.newInstance(typesOfParameters[0], paramset.length);
for (int i = 0; i < paramset.length; i++) {
((Object[]) resultParam)[i] = paramset[i];
}
} else {
resultParam = testMethod.getMethod().getParameterTypes()[0].getConstructor(typesOfParameters).newInstance(paramset);
}
} catch (Exception e) {
throw new IllegalStateException("While trying to create object of class " + testMethod.getMethod().getParameterTypes()[0]
+ " could not find constructor with arguments matching (type-wise) the ones given in parameters.", e);
}
return resultParam;
}
private Class<?>[] createArrayOfTypesOf(Object[] paramset) {
Class<?>[] parametersBasedOnValues = new Class<?>[paramset.length];
for (int i = 0; i < paramset.length; i++) {
parametersBasedOnValues[i] = paramset[i].getClass();
}
return parametersBasedOnValues;
}
private Object[] castParamsUsingConverters(Object[] columns) throws ConversionFailedException {
Class<?>[] expectedParameterTypes = testMethod.getMethod().getParameterTypes();
if (testMethodParamsHasVarargs(columns, expectedParameterTypes)) {
columns = columnsWithVarargs(columns, expectedParameterTypes);
}
Annotation[][] parameterAnnotations = testMethod.getMethod().getParameterAnnotations();
verifySameSizeOfArrays(columns, expectedParameterTypes);
columns = castAllParametersToProperTypes(columns, expectedParameterTypes, parameterAnnotations);
return columns;
}
private Object[] columnsWithVarargs(Object[] columns, Class<?>[] expectedParameterTypes) {
Object[] allParameters = standardParameters(columns, expectedParameterTypes);
allParameters[allParameters.length - 1] = varargsParameters(columns, expectedParameterTypes);
return allParameters;
}
private Object[] varargsParameters(Object[] columns, Class<?>[] expectedParameterTypes) {
Class<?> varArgType = expectedParameterTypes[expectedParameterTypes.length - 1].getComponentType();
Object[] varArgsParameters = (Object[]) Array.newInstance(varArgType, columns.length - expectedParameterTypes.length + 1);
for (int i = 0; i < varArgsParameters.length; i++) {
varArgsParameters[i] = columns[i + expectedParameterTypes.length - 1];
}
return varArgsParameters;
}
private Object[] standardParameters(Object[] columns, Class<?>[] expectedParameterTypes) {
Object[] standardParameters = new Object[expectedParameterTypes.length];
for (int i = 0; i < standardParameters.length - 1; i++) {
standardParameters[i] = columns[i];
}
return standardParameters;
}
private boolean testMethodParamsHasVarargs(Object[] columns, Class<?>[] expectedParameterTypes) {
int last = expectedParameterTypes.length - 1;
if (columns[last] == null) {
return false;
}
return expectedParameterTypes.length <= columns.length
&& expectedParameterTypes[last].isArray()
&& expectedParameterTypes[last].getComponentType().equals(columns[last].getClass());
}
private Object[] castAllParametersToProperTypes(Object[] columns, Class<?>[] expectedParameterTypes,
Annotation[][] parameterAnnotations) throws ConversionFailedException {
Object[] result = new Object[columns.length];
for (int i = 0; i < columns.length; i++) {
if (parameterAnnotations[i].length == 0)
result[i] = castParameterDirectly(columns[i], expectedParameterTypes[i]);
else
result[i] = castParameterUsingConverter(columns[i], parameterAnnotations[i]);
}
return result;
}
private Object castParameterUsingConverter(Object param, Annotation[] annotations) throws ConversionFailedException {
for (Annotation annotation : annotations) {
if (ParamAnnotation.matches(annotation)) {
return ParamAnnotation.convert(annotation, param);
}
if (annotation.annotationType().isAssignableFrom(ConvertParam.class)) {
Class<? extends ParamConverter<?>> converterClass = ((ConvertParam) annotation).value();
String options = ((ConvertParam) annotation).options();
try {
return converterClass.newInstance().convert(param, options);
} catch (ConversionFailedException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException("Your ParamConverter class must have a public no-arg constructor!", e);
}
}
}
return param;
}
@SuppressWarnings("unchecked")
private Object castParameterDirectly(Object object, Class clazz) {
if (object == null || clazz.isInstance(object) || (!(object instanceof String) && clazz.isPrimitive()))
return object;
if (clazz.isEnum())
return (Enum.valueOf(clazz, (String) object));
if (clazz.isAssignableFrom(String.class))
return object.toString();
if (clazz.isAssignableFrom(Class.class))
try {
return Class.forName((String) object);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Parameter class (" + object + ") not found", e);
}
if (clazz.isAssignableFrom(Integer.TYPE) || clazz.isAssignableFrom(Integer.class))
return Integer.parseInt((String) object);
if (clazz.isAssignableFrom(Short.TYPE) || clazz.isAssignableFrom(Short.class))
return Short.parseShort((String) object);
if (clazz.isAssignableFrom(Long.TYPE) || clazz.isAssignableFrom(Long.class))
return Long.parseLong((String) object);
if (clazz.isAssignableFrom(Float.TYPE) || clazz.isAssignableFrom(Float.class))
return Float.parseFloat((String) object);
if (clazz.isAssignableFrom(Double.TYPE) || clazz.isAssignableFrom(Double.class))
return Double.parseDouble((String) object);
if (clazz.isAssignableFrom(Boolean.TYPE) || clazz.isAssignableFrom(Boolean.class))
return Boolean.parseBoolean((String) object);
if (clazz.isAssignableFrom(Character.TYPE) || clazz.isAssignableFrom(Character.class))
return object.toString().charAt(0);
if (clazz.isAssignableFrom(Byte.TYPE) || clazz.isAssignableFrom(Byte.class))
return Byte.parseByte((String) object);
if (clazz.isAssignableFrom(BigDecimal.class))
return new BigDecimal((String) object);
throw new IllegalArgumentException("Parameter type (" + clazz.getName() + ") cannot be handled!" +
" Only primitive types, BigDecimals and Strings can be used.");
}
private void verifySameSizeOfArrays(Object[] columns, Class<?>[] parameterTypes) {
if (parameterTypes.length != columns.length)
throw new IllegalArgumentException(
"Number of parameters inside @Parameters annotation doesn't match the number of test method parameters.\nThere are "
+ columns.length + " parameters in annotation, while there's " + parameterTypes.length + " parameters in the "
+ testMethod.getName() + " method.");
}
boolean matchesDescription(Description description) {
return description.hashCode() == uniqueMethodId.hashCode();
}
@Override
public void evaluate() throws Throwable {
testMethod.invokeExplosively(testClass, params == null ? new Object[]{params} : params);
}
}
|
