@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {
Thread currentThread = Thread.currentThread();
ClassLoader contextClassLoader = currentThread.getContextClassLoader();
PortalClassLoaderUtil.setClassLoader(contextClassLoader);
TestClass testClass = getTestClass();
List<FrameworkMethod> beforeFrameworkMethods = testClass.getAnnotatedMethods(Before.class);
List<FrameworkMethod> afterFrameworkMethods = testClass.getAnnotatedMethods(After.class);
List<String> arguments = createArguments(frameworkMethod);
Class<?> clazz = testClass.getJavaClass();
return new RunInNewJVMStatment(
_classPath,
arguments,
clazz,
beforeFrameworkMethods,
frameworkMethod,
afterFrameworkMethods);
}
/**
* 判断是否需要执行MilouDbUnitTestExecutionListener
*
* @param testClass
*/
private void switchMilouDBUnitTestExecutionListener(TestClass testClass) {
List<FrameworkMethod> DBSituations = testClass.getAnnotatedMethods(DBSituations.class);
List<FrameworkMethod> DBSetupSituation = testClass.getAnnotatedMethods(DBSetupSituation.class);
List<FrameworkMethod> DBTeardownSituation =
testClass.getAnnotatedMethods(DBTeardownSituation.class);
if (!CollectionUtils.isEmpty(DBSituations)
|| !CollectionUtils.isEmpty(DBSetupSituation)
|| !CollectionUtils.isEmpty(DBTeardownSituation)) {
MilouDBThreadLocal.setMilouDBListener(Boolean.valueOf(true));
}
}
@SuppressWarnings("deprecation")
private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
for (FrameworkMethod dataPointMethod : fClass.getAnnotatedMethods(DataPoint.class)) {
Class<?> type = sig.getType();
if ((dataPointMethod.producesType(type))) list.add(new MethodParameterValue(dataPointMethod));
}
}
private void addMultiPointMethods(List<PotentialAssignment> list) {
for (FrameworkMethod dataPointsMethod : fClass.getAnnotatedMethods(DataPoints.class))
try {
addArrayValues(dataPointsMethod.getName(), list, dataPointsMethod.invokeExplosively(null));
} catch (Throwable e) {
// ignore and move on
}
}
/** @see Parameterized */
private FrameworkMethod getParametersMethod(TestClass testClass) throws Exception {
List<FrameworkMethod> methods = testClass.getAnnotatedMethods(Parameterized.Parameters.class);
for (FrameworkMethod each : methods) {
int modifiers = each.getMethod().getModifiers();
if (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers)) return each;
}
throw new Exception("No public static parameters method on class " + testClass.getName());
}
private void setAllSituationIntoMap(TestClass testClass) {
List<FrameworkMethod> frameworkMethods = testClass.getAnnotatedMethods(Test.class);
for (FrameworkMethod method : frameworkMethods) {
List<SituationInfo> list = getSituationInfos(method);
if (!CollectionUtils.isEmpty(list)) {
situationInfos.put(method, list);
}
}
}
public TestClassAttributes(
TestClass testClass, ClassResolver classResolver, DependencyCollector dependencyCollector) {
beforeMethods = testClass.getAnnotatedMethods(Before.class);
afterMethods = testClass.getAnnotatedMethods(After.class);
stjsClass = classResolver.resolve(testClass.getName());
htmlFixture = testClass.getJavaClass().getAnnotation(HTMLFixture.class);
scripts =
getScriptsPathes(
testClass.getJavaClass(),
Scripts.class,
new Function1<Annotation, Collection<String>>() {
@Override
public Collection<String> $invoke(Annotation annotation) {
return Arrays.asList(Scripts.class.cast(annotation).value());
}
});
scriptsBefore =
getScriptsPathes(
testClass.getJavaClass(),
ScriptsBefore.class,
new Function1<Annotation, Collection<String>>() {
@Override
public Collection<String> $invoke(Annotation annotation) {
return Arrays.asList(ScriptsBefore.class.cast(annotation).value());
}
});
scriptsAfter =
getScriptsPathes(
testClass.getJavaClass(),
ScriptsAfter.class,
new Function1<Annotation, Collection<String>>() {
@Override
public Collection<String> $invoke(Annotation annotation) {
return Arrays.asList(ScriptsAfter.class.cast(annotation).value());
}
});
dependencies = dependencyCollector.orderAllDependencies(stjsClass);
}
@Test
public void providesAnnotatedMethodsSortedByName() {
TestClass tc = new TestClass(MethodsAnnotated.class);
List<FrameworkMethod> annotatedMethods = tc.getAnnotatedMethods();
assertThat("Wrong number of annotated methods.", annotatedMethods.size(), is(3));
assertThat(
"First annotated method is wrong.",
annotatedMethods.iterator().next().getName(),
is("methodA"));
}
public InternalRemoteRunner(
Class<?> testClass, String endpoint, Class<? extends Runner> remoteRunnerClass)
throws InitializationError {
super(testClass);
this.testClass = testClass;
this.remoteRunnerClass = remoteRunnerClass;
TestClass tc = new TestClass(testClass);
description = Description.createTestDescription(testClass, tc.getName(), tc.getAnnotations());
for (FrameworkMethod method : tc.getAnnotatedMethods(Test.class)) {
String methodName = method.getName();
Description child =
Description.createTestDescription(testClass, methodName, method.getAnnotations());
methodNames.put(child, methodName);
description.addChild(child);
}
if (executorService == null) {
String ep = System.getProperty("junit.remote.endpoint");
if (ep == null) {
ep = endpoint;
}
for (String e : ep.split(",")) {
if (e.trim().equals("")) {
continue;
}
endpoints.add(e.trim());
}
executorService = Executors.newFixedThreadPool(endpoints.size());
}
setScheduler(
new RunnerScheduler() {
@Override
public void schedule(final Runnable childStatement) {
SEMAPHORE.reducePermits(1);
executorService.submit(new SemaphoreDelegate(childStatement));
}
@Override
public void finished() {
try {
SEMAPHORE.acquire();
SEMAPHORE.release();
} catch (InterruptedException ignore) {
Thread.currentThread().interrupt();
}
}
});
}
protected static List<MethodKey> getMethodKeys(
Class<?> targetClass, Class<? extends Annotation> annotationClass) {
TestClass testClass = new TestClass(targetClass);
List<FrameworkMethod> frameworkMethods = testClass.getAnnotatedMethods(annotationClass);
List<MethodKey> methodKeys = new ArrayList<MethodKey>(frameworkMethods.size());
for (FrameworkMethod annotatedFrameworkMethod : frameworkMethods) {
methodKeys.add(new MethodKey(annotatedFrameworkMethod.getMethod()));
}
return methodKeys;
}
public int getMaxTestNameLen() {
if (0 == maxMethodNameLen) {
int ml = 0;
final TestClass tc = new TestClass(getClass());
final List<FrameworkMethod> testMethods = tc.getAnnotatedMethods(org.junit.Test.class);
for (Iterator<FrameworkMethod> iter = testMethods.iterator(); iter.hasNext(); ) {
final int l = iter.next().getName().length();
if (ml < l) {
ml = l;
}
}
maxMethodNameLen = ml;
}
return maxMethodNameLen;
}
private void handleInitializationError(
final boolean developmentMode,
final List<TestClassResult> result,
final String klassName,
final Class<?> klass,
final InitializationError e) {
TestClass testClass = new TestClass(klass);
boolean allMethods =
(!developmentMode) || (klass.getAnnotation(TestDuringDevelopment.class) != null);
List<Throwable> causes = e.getCauses();
long now = System.currentTimeMillis();
List<TestCaseResult> testCaseResults = new ArrayList<TestCaseResult>();
List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(Test.class);
Exception wrapperException = new Exception("Error during initialization. See log for details");
wrapperException.setStackTrace(new StackTraceElement[0]);
for (FrameworkMethod frameworkMethod : annotatedMethods) {
if (allMethods || (frameworkMethod.getAnnotation(TestDuringDevelopment.class) != null)) {
TestCaseResult testCaseResult =
new TestCaseResult(frameworkMethod.getName(), now, now, wrapperException);
testCaseResults.add(testCaseResult);
}
}
TestClassResult classResult =
new TestClassResult(klassName, 0, testCaseResults.size(), 0, 0, now, now, testCaseResults);
result.add(classResult);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
pw.write("Error during initialization of test class '" + klassName + "':\n");
for (Throwable throwable : causes) {
throwable.printStackTrace(pw);
}
LOGGER.log(Level.SEVERE, sw.toString());
}
private List<TestCaseResult> createErrorTestCaseResults(
final Class<?> klass, final boolean developmentMode, final long now) {
TestClass testClass = new TestClass(klass);
boolean allMethods =
(!developmentMode) || (klass.getAnnotation(TestDuringDevelopment.class) != null);
List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(Test.class);
List<TestCaseResult> result = new ArrayList<TestCaseResult>();
for (FrameworkMethod frameworkMethod : annotatedMethods) {
if (allMethods || (frameworkMethod.getAnnotation(TestDuringDevelopment.class) != null)) {
Exception exception =
new Exception(
"Service object behind the reference was null. We experienced this when the activate"
+ " method of a DS component threw an exception but there can be other causes. Please"
+ " check the log! Please note, that in Equinox sometimes such exceptions are"
+ " written only into different files in the configuration folder.");
exception.setStackTrace(new StackTraceElement[0]);
result.add(new TestCaseResult(frameworkMethod.getName(), now, now, exception));
}
}
return result;
}
/** 完成Stub的元数据扫描,构建stub元数据仓库 */
private void stubInfoRepoInit(TestClass testClass) {
// 加载本地stub仓库
List<FrameworkMethod> stubMethods = testClass.getAnnotatedMethods(Stub.class);
if (!CollectionUtils.isEmpty(stubMethods)) {
for (FrameworkMethod fm : stubMethods) {
StubInfo info = new StubInfo();
String stubId = fm.getAnnotation(Stub.class).value();
info.setStubId(stubId);
info.setStubClass(testClass.getJavaClass());
info.setStubMethod(fm.getMethod());
logger.info("[milou] scan stub,stubId={}", stubId);
StubInfoRepo.setIntoStubInfoRepo(stubId, info);
}
}
StubLocation locationAnno = testClass.getJavaClass().getAnnotation(StubLocation.class);
if (locationAnno != null && !locationAnno.value().equals(StubLocation.LOCAL)) {
// 根据注解加载指定路径下的stub仓库
List<Class<?>> scanList = PackageScanner.getStubClass(locationAnno.value());
StubInfoScanner.scanAllStubClass(scanList, StubInfoRepo.getStubInfoRepo());
}
}
/**
* Returns a {@link Statement}: run all non-overridden {@code @AfterClass} methods on this class
* and superclasses before executing {@code statement}; all AfterClass methods are always
* executed: exceptions thrown by previous steps are combined, if necessary, with exceptions from
* AfterClass methods into a {@link MultipleFailureException}.
*/
protected Statement withAfterClasses(Statement statement) {
List<FrameworkMethod> afters = fTestClass.getAnnotatedMethods(AfterClass.class);
return afters.isEmpty() ? statement : new RunAfters(statement, afters, null);
}
/**
* Returns a {@link Statement}: run all non-overridden {@code @BeforeClass} methods on this class
* and superclasses before executing {@code statement}; if any throws an Exception, stop execution
* and pass the exception on.
*/
protected Statement withBeforeClasses(Statement statement) {
List<FrameworkMethod> befores = fTestClass.getAnnotatedMethods(BeforeClass.class);
return befores.isEmpty() ? statement : new RunBefores(statement, befores, null);
}