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
|
package junitparams.internal;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Ignore;
import org.junit.runner.Description;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.TestClass;
import junitparams.internal.annotation.FrameworkMethodAnnotations;
import junitparams.internal.parameters.ParametersReader;
import junitparams.naming.MacroSubstitutionNamingStrategy;
import junitparams.naming.TestCaseNamingStrategy;
/**
* A wrapper for a test method
*
* @author Pawel Lipinski
*/
public class TestMethod {
private FrameworkMethod frameworkMethod;
FrameworkMethodAnnotations frameworkMethodAnnotations;
private Class<?> testClass;
private ParametersReader parametersReader;
private Object[] cachedParameters;
private TestCaseNamingStrategy namingStrategy;
public TestMethod(FrameworkMethod method, TestClass testClass) {
this.frameworkMethod = method;
this.testClass = testClass.getJavaClass();
frameworkMethodAnnotations = new FrameworkMethodAnnotations(method);
parametersReader = new ParametersReader(testClass(), frameworkMethod);
namingStrategy = new MacroSubstitutionNamingStrategy(this);
}
public String name() {
return frameworkMethod.getName();
}
public static List<TestMethod> listFrom(List<FrameworkMethod> annotatedMethods, TestClass testClass) {
List<TestMethod> methods = new ArrayList<TestMethod>();
for (FrameworkMethod frameworkMethod : annotatedMethods)
methods.add(new TestMethod(frameworkMethod, testClass));
return methods;
}
@Override
public int hashCode() {
return frameworkMethod.hashCode();
}
@Override
public boolean equals(Object obj) {
return (obj instanceof TestMethod)
&& hasTheSameNameAsFrameworkMethod((TestMethod) obj)
&& hasTheSameParameterTypesAsFrameworkMethod((TestMethod) obj);
}
private boolean hasTheSameNameAsFrameworkMethod(TestMethod testMethod) {
return frameworkMethod.getName().equals(testMethod.frameworkMethod.getName());
}
private boolean hasTheSameParameterTypesAsFrameworkMethod(TestMethod testMethod) {
Class<?>[] frameworkMethodParameterTypes = frameworkMethod.getMethod().getParameterTypes();
Class<?>[] testMethodParameterTypes = testMethod.frameworkMethod.getMethod().getParameterTypes();
return Arrays.equals(frameworkMethodParameterTypes, testMethodParameterTypes);
}
Class<?> testClass() {
return testClass;
}
public boolean isIgnored() {
return hasIgnoredAnnotation() || hasNoParameters();
}
private boolean hasIgnoredAnnotation() {
return frameworkMethodAnnotations.hasAnnotation(Ignore.class);
}
private boolean hasNoParameters() {
return isParameterised() && parametersSets().length == 0;
}
public boolean isNotIgnored() {
return !isIgnored();
}
public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
return frameworkMethodAnnotations.getAnnotation(annotationType);
}
Description describe() {
if (isNotIgnored() && !describeFlat()) {
Description parametrised = Description.createSuiteDescription(name());
Object[] params = parametersSets();
for (int i = 0; i < params.length; i++) {
Object paramSet = params[i];
String name = namingStrategy.getTestCaseName(i, paramSet);
String uniqueMethodId = Utils.uniqueMethodId(i, paramSet, name());
parametrised.addChild(
Description.createTestDescription(testClass().getName(), name, uniqueMethodId)
);
}
return parametrised;
} else {
return Description.createTestDescription(testClass(), name(), frameworkMethodAnnotations.allAnnotations());
}
}
private boolean describeFlat() {
return System.getProperty("JUnitParams.flat") != null;
}
public Object[] parametersSets() {
if (cachedParameters == null) {
cachedParameters = parametersReader.read();
}
return cachedParameters;
}
void warnIfNoParamsGiven() {
if (isNotIgnored() && isParameterised() && parametersSets().length == 0)
System.err.println("Method " + name() + " gets empty list of parameters, so it's being ignored!");
}
public FrameworkMethod frameworkMethod() {
return frameworkMethod;
}
boolean isParameterised() {
return frameworkMethodAnnotations.isParametrised();
}
}
|
