Java 类org.junit.runners.Suite.SuiteClasses 实例源码

@SuppressWarnings({"rawtypes", "LoopStatementThatDoesntLoop"})
private boolean assertTestRunner(String testClass) {
  try {
    RunWith runWith = Class.forName(testClass).getAnnotation(RunWith.class);
    if (runWith == null) {
      throw new RuntimeException("Missing [@" + RunWith.class.getCanonicalName() + "(" + TestRunner.class.getCanonicalName()
        + ".class)] on class [" + testClass + "]");
    }
    if (runWith.value().equals(Suite.class)) {
      SuiteClasses suiteClasses = Class.forName(testClass).getAnnotation(SuiteClasses.class);
      for (Class suiteTestClass : suiteClasses.value()) {
        return assertTestRunner(suiteTestClass.getCanonicalName());
      }
    } else if (!runWith.value().equals(TestRunner.class)) {
      throw new RuntimeException("Unsupported run with [" + runWith.value().getCanonicalName() + "] on class [" + testClass + "]");
    }
  } catch (Exception exception) {
    String message = "The test [" + testClass + "] included a rule [" + getClass().getCanonicalName() + "] but did not include a [@"
      + RunWith.class.getCanonicalName() + "(" + TestRunner.class.getCanonicalName() + ".class)] class annotation";
    if (LOG.isErrorEnabled()) {
      LOG.error(message, exception);
    }
    throw new RuntimeException(message, exception);
  }
  return true;
}

/**
 * @see junitconverter.stages.TestConversionStage#convertClass(junitconverter.testcase.TestCaseClass)
 */
public void convertClass(TestCaseClass testCase)
{
    // This is a gigantic hack. We use a regex to search for classes/suites added to the suite.
    // We start our search at the beginning of the suite method
    List<String> lines = testCase.getLines().subList(testCase.getSuiteStartLine(), testCase.getSuiteEndLine() + 1);
    StringBuilder builder = new StringBuilder();
    builder.append('{');
    for (String line : lines)
    {
        Matcher m = p.matcher(line);
        if (m.find())
        {
            String testName = m.group(2);
            builder.append(testName).append(".class, "); //$NON-NLS-1$
        }
    }
    builder.append('}');
    codeEditor.addAnnotation(testCase, SuiteClasses.class, builder.toString());
    codeEditor.addAnnotation(testCase, RunWith.class, "Suite.class"); //$NON-NLS-1$
}

/**
 * @see Suite#getAnnotatedClasses(Class)
 */
public static Class<?>[] getSuiteClasses(Class<?> klass) throws InitializationError {
    SuiteClasses annotation = klass.getAnnotation(SuiteClasses.class);
    if (annotation == null) {
        throw new InitializationError(String.format("class '%s' must have a SuiteClasses annotation", klass.getName()));
    }
    return annotation.value();
}

public boolean registerFromAnnotatedClass(Class<?> annotatedClass) throws InitializationError
{
    Util.assume(annotatedClass != null, "anntatedClass is null");
    if (registeredAnnotatedClasses.contains(annotatedClass))
    {
        return false;
    }

    final IntegrationTestListeners annListeners = annotatedClass.getAnnotation(IntegrationTestListeners.class);
    if (annListeners != null)
    {
        Class<?>[] listenerClasses = annListeners.value();
        if (listenerClasses == null || listenerClasses.length == 0)
        {
            throw new InitializationError("No listeners specified on " + annListeners + " for " + annotatedClass);
        }

        for (Class<?> listenerClass : listenerClasses)
            registerListenerClass(listenerClass);
    }

    registeredAnnotatedClasses.add(annotatedClass);

    final SuiteClasses annSuiteClasses = annotatedClass.getAnnotation(SuiteClasses.class);
    if (annSuiteClasses != null)
    {
        Class<?>[] suiteClasses = annSuiteClasses.value();
        if (suiteClasses != null)
        {
            for (Class<?> suiteClass : suiteClasses)
            {
                registerFromAnnotatedClass(suiteClass);
            }
        }
    }

    return true;
}

@Override
public List<Class<?>> apply(final Class<?> a) {
  final SuiteClasses annotation = a.getAnnotation(SuiteClasses.class);

  if ((annotation != null) && hasSuitableRunnner(a)) {
    return Arrays.asList(annotation.value());
  } else {
    return Collections.emptyList();
  }
}

/**
 * @see junitconverter.stages.TestConversionStage#convertClass(junitconverter.testcase.TestCaseClass)
 */
public void convertClass(TestCaseClass testCase)
{
    codeEditor.importClass(testCase, Suite.class);
    codeEditor.importClass(testCase, RunWith.class);
    codeEditor.importClass(testCase, SuiteClasses.class); // FIXME Doesn't import it properly. Adds a $ instead of . between SUite and SuiteClasses
}