Class<?> addParent(Class<?> parent) throws InitializationError { if (!parents.add(parent)) { throw new InitializationError(String.format("class '%s' (possibly indirectly) contains itself as a SuiteClass", parent.getName())); } return parent; }
@SuppressWarnings("deprecation") private List<Throwable> getCauses(Throwable cause) { if (cause instanceof InvocationTargetException) { return getCauses(cause.getCause()); } if (cause instanceof InvalidTestClassError) { return singletonList(cause); } if (cause instanceof InitializationError) { return ((InitializationError) cause).getCauses(); } if (cause instanceof org.junit.internal.runners.InitializationError) { return ((org.junit.internal.runners.InitializationError) cause) .getCauses(); } return singletonList(cause); }
Class<?> addParent(Class<?> parent) throws InitializationError { if (!parents.add(parent)) { throw new InitializationError(String.format("class '%s' (possibly indirectly) contains itself as a SuiteClass", parent.getName())); } return parent; }
@SuppressWarnings("deprecation") private List<Throwable> getCauses(Throwable cause) { if (cause instanceof InvocationTargetException) { return getCauses(cause.getCause()); } if (cause instanceof InitializationError) { return ((InitializationError) cause).getCauses(); } if (cause instanceof org.junit.internal.runners.InitializationError) { return ((org.junit.internal.runners.InitializationError) cause) .getCauses(); } return Arrays.asList(cause); }
private static Class<?>[] getAnnotatedClasses(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(); }
errors.addAll( failure.getCauses() );
public Runner buildRunner(Class<? extends Runner> runnerClass, Class<?> testClass) throws Exception { try { return runnerClass.getConstructor(Class.class).newInstance(testClass); } catch (NoSuchMethodException e) { try { return runnerClass.getConstructor(Class.class, RunnerBuilder.class).newInstance(testClass, suiteBuilder); } catch (NoSuchMethodException e2) { String simpleName = runnerClass.getSimpleName(); throw new InitializationError(String.format( CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName)); } } } }
@SuppressWarnings("deprecation") private List<Throwable> getCauses(Throwable cause) { if (cause instanceof InvocationTargetException) { return getCauses(cause.getCause()); } if (cause instanceof InitializationError) { return ((InitializationError) cause).getCauses(); } if (cause instanceof org.junit.internal.runners.InitializationError) { return ((org.junit.internal.runners.InitializationError) cause) .getCauses(); } return Arrays.asList(cause); }
private void validate() throws InitializationError { List<Throwable> errors = new ArrayList<Throwable>(); collectInitializationErrors(errors); if (!errors.isEmpty()) { throw new InitializationError(errors); } }
@Override public boolean matchesSafely(InitializationError initializationError) { return causesMatcher.matches(initializationError.getCauses()); }
private static Class<?>[] getAnnotatedClasses(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(); }
/** * Clients may override this method to add additional behavior when a {@link InitializationError} is raised. * The call of this method is guaranteed. * * @param notifier the notifier * @param e the error */ protected void whenInitializationErrorIsRaised(final EachTestNotifier notifier, final InitializationError e) { notifier.addFailure(new MultipleFailureException(e.getCauses())); }
public Runner buildRunner(Class<? extends Runner> runnerClass, Class<?> testClass) throws Exception { try { return runnerClass.getConstructor(Class.class).newInstance( new Object[]{testClass}); } catch (NoSuchMethodException e) { try { return runnerClass.getConstructor(Class.class, RunnerBuilder.class).newInstance( new Object[]{testClass, fSuiteBuilder}); } catch (NoSuchMethodException e2) { String simpleName = runnerClass.getSimpleName(); throw new InitializationError(String.format( CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName)); } } } }
public Sputnik(Class<?> clazz) throws InitializationError { try { VersionChecker.checkGroovyVersion("JUnit runner"); } catch (IncompatibleGroovyVersionException e) { throw new InitializationError(e); } this.clazz = clazz; }
/** * Creates a {@link Request}. * * @param computer {@link Computer} to be used. */ public Request createRequest(Computer computer) { if (parserErrors.isEmpty()) { Request request = Request.classes( computer, classes.toArray(new Class<?>[classes.size()])); return applyFilterSpecs(request); } else { return errorReport(new InitializationError(parserErrors)); } }
private RuleTst createTestClass() throws InitializationError { try { return (RuleTst) getTestClass().getOnlyConstructor().newInstance(); } catch (Exception e) { throw new InitializationError(e); } }
public class SeparateClassloaderTestRunner extends BlockJUnit4ClassRunner { public SeparateClassloaderTestRunner(Class<?> clazz) throws InitializationError { super(getFromTestClassloader(clazz)); } private static Class<?> getFromTestClassloader(Class<?> clazz) throws InitializationError { try { ClassLoader testClassLoader = new TestClassLoader(); return Class.forName(clazz.getName(), true, testClassLoader); } catch (ClassNotFoundException e) { throw new InitializationError(e); } } public static class TestClassLoader extends URLClassLoader { public TestClassLoader() { super(((URLClassLoader)getSystemClassLoader()).getURLs()); } @Override public Class<?> loadClass(String name) throws ClassNotFoundException { if (name.startsWith("org.mypackages.")) { return super.findClass(name); } return super.loadClass(name); } } }
private void assertNoDescendantsHaveCategoryAnnotations(Description description) throws InitializationError { for (Description each : description.getChildren()) { if (each.getAnnotation(Category.class) != null) { throw new InitializationError("Category annotations on Parameterized classes are not supported on individual methods."); } assertNoDescendantsHaveCategoryAnnotations(each); } }
private static List<Runner> getRunners(final Class<?> testClass) throws InitializationError { SuiteClasses annotation = testClass.getAnnotation(SuiteClasses.class); if (annotation == null) { throw new InitializationError( String.format("class '%s' must have a SuiteClasses annotation", testClass.getName())); } SuiteRunner.Candidate candidate = testClass.getAnnotation(Candidate.class); Class<?> candidateClass = null; if (candidate != null) { candidateClass = candidate.value(); } Class<?>[] childClasses = annotation.value(); List<Runner> runners = new ArrayList<>(); for (Class childClass : childClasses) { runners.add(new SuiteBlockRunner(testClass, childClass)); if (candidateClass != null) { runners.add(new SuiteBlockRunner(testClass, candidateClass)); } } return runners; } }
public TeaVMTestRunner(Class<?> testClass) throws InitializationError { this.testClass = testClass; classLoader = TeaVMTestRunner.class.getClassLoader(); classSource = getClassSource(classLoader); String outputPath = System.getProperty(PATH_PARAM); if (outputPath != null) { outputDir = new File(outputPath); } String runStrategyName = System.getProperty(JS_RUNNER); if (runStrategyName != null) { TestRunStrategy jsRunStrategy; switch (runStrategyName) { case "htmlunit": jsRunStrategy = new HtmlUnitRunStrategy(); break; case "": case "none": jsRunStrategy = null; break; default: throw new InitializationError("Unknown run strategy: " + runStrategyName); } runners.get(RunKind.JAVASCRIPT).strategy = jsRunStrategy; } String cCommand = System.getProperty(C_COMPILER); if (cCommand != null) { runners.get(RunKind.C).strategy = new CRunStrategy(cCommand); } }