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; }
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; }
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(); }
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)); } } } }
private void validate() throws InitializationError { List<Throwable> errors = new ArrayList<Throwable>(); collectInitializationErrors(errors); if (!errors.isEmpty()) { throw new InitializationError(errors); } }
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(); }
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); } }
public ConcurrentTestRunner(Class testClass) throws InitializationError { super(testClass); ConcurrentTestConfig configuration = getTestClass().getAnnotation(ConcurrentTestConfig.class); if (configuration == null) { runner = new LoopRunner(); return; } try { runner = configuration.runner().newInstance(); } catch (InstantiationException | IllegalAccessException e) { throw new InitializationError(e); } }
if ( !errors.isEmpty() ) throw new InitializationError( errors );
public Categories(Class<?> klass, RunnerBuilder builder) throws InitializationError { super(klass, builder); try { Set<Class<?>> included= getIncludedCategory(klass); Set<Class<?>> excluded= getExcludedCategory(klass); boolean isAnyIncluded= isAnyIncluded(klass); boolean isAnyExcluded= isAnyExcluded(klass); filter(CategoryFilter.categoryFilter(isAnyIncluded, included, isAnyExcluded, excluded)); } catch (NoTestsRemainException e) { throw new InitializationError(e); } }
public Categories(Class<?> klass, RunnerBuilder builder) throws InitializationError { super(klass, builder); try { filter(new CategoryFilter(getIncludedCategory(klass), getExcludedCategory(klass))); } catch (NoTestsRemainException e) { throw new InitializationError(e); } assertNoCategorizedDescendentsOfUncategorizeableParents(getDescription()); }
Class<?> appClass = klass; if (!Jooby.class.isAssignableFrom(appClass)) { throw new InitializationError("Invalid jooby app: " + appClass); throw new InitializationError(Arrays.asList(ex));
public Categories(Class<?> klass, RunnerBuilder builder) throws InitializationError { super(klass, builder); try { filter(new CategoryFilter(getIncludedCategory(klass), getExcludedCategory(klass))); } catch (NoTestsRemainException e) { throw new InitializationError(e); } assertNoCategorizedDescendentsOfUncategorizeableParents(getDescription()); }