blob: 1ca2b9d1d95260d4ab14a5608d16e0be7b7e9cf6 (
plain)
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
|
package org.junit.internal.runners;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runners.BlockJUnit4ClassRunner;
/**
* @deprecated Included for backwards compatibility with JUnit 4.4. Will be
* removed in the next release. Please use
* {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
*/
@Deprecated
public class TestClass {
private final Class<?> fClass;
public TestClass(Class<?> klass) {
fClass= klass;
}
public List<Method> getTestMethods() {
return getAnnotatedMethods(Test.class);
}
List<Method> getBefores() {
return getAnnotatedMethods(BeforeClass.class);
}
List<Method> getAfters() {
return getAnnotatedMethods(AfterClass.class);
}
public List<Method> getAnnotatedMethods(Class<? extends Annotation> annotationClass) {
List<Method> results= new ArrayList<Method>();
for (Class<?> eachClass : getSuperClasses(fClass)) {
Method[] methods= eachClass.getDeclaredMethods();
for (Method eachMethod : methods) {
Annotation annotation= eachMethod.getAnnotation(annotationClass);
if (annotation != null && ! isShadowed(eachMethod, results))
results.add(eachMethod);
}
}
if (runsTopToBottom(annotationClass))
Collections.reverse(results);
return results;
}
private boolean runsTopToBottom(Class< ? extends Annotation> annotation) {
return annotation.equals(Before.class) || annotation.equals(BeforeClass.class);
}
private boolean isShadowed(Method method, List<Method> results) {
for (Method each : results) {
if (isShadowed(method, each))
return true;
}
return false;
}
private boolean isShadowed(Method current, Method previous) {
if (! previous.getName().equals(current.getName()))
return false;
if (previous.getParameterTypes().length != current.getParameterTypes().length)
return false;
for (int i= 0; i < previous.getParameterTypes().length; i++) {
if (! previous.getParameterTypes()[i].equals(current.getParameterTypes()[i]))
return false;
}
return true;
}
private List<Class<?>> getSuperClasses(Class< ?> testClass) {
ArrayList<Class<?>> results= new ArrayList<Class<?>>();
Class<?> current= testClass;
while (current != null) {
results.add(current);
current= current.getSuperclass();
}
return results;
}
public Constructor<?> getConstructor() throws SecurityException, NoSuchMethodException {
return fClass.getConstructor();
}
public Class<?> getJavaClass() {
return fClass;
}
public String getName() {
return fClass.getName();
}
}
|
