Examples with AntClassLoader org.apache.tools.ant.AntClassLoader used on opensource projects

Example 6 with AntClassLoader

use of org.apache.tools.ant.AntClassLoader in project quasar by puniverse.

the class SuspendablesScanner method run.

public void run() {
    try {
        // System.err.println("QQQQQQQQ: " + new SimpleSuspendableClassifier(supersFile).getSuspendableClasses());
        final List<URL> us = new ArrayList<>();
        if (ant) {
            final AntClassLoader acl = (AntClassLoader) getClass().getClassLoader();
            classpathToUrls(acl.getClasspath().split(System.getProperty("path.separator")), us);
            for (FileSet fs : filesets) us.add(fs.getDir().toURI().toURL());
        } else {
            final URLClassLoader ucl = (URLClassLoader) getClass().getClassLoader();
            us.addAll(Arrays.asList(ucl.getURLs()));
        }
        setURLs(us);
        log("Classpath URLs: " + Arrays.toString(this.urls), Project.MSG_INFO);
        List<URL> pus = new ArrayList<>();
        if (ant) {
            for (FileSet fs : filesets) pus.add(fs.getDir().toURI().toURL());
        } else
            pus.add(projectDir.toUri().toURL());
        log("Project URLs: " + pus, Project.MSG_INFO);
        final long tStart = System.nanoTime();
        scanExternalSuspendables();
        final long tScanExternal = System.nanoTime();
        if (auto)
            log("Scanned external suspendables in " + (tScanExternal - tStart) / 1000000 + " ms", Project.MSG_INFO);
        // scan classes in filesets
        Function<InputStream, Void> fileVisitor = new Function<InputStream, Void>() {

            @Override
            public Void apply(InputStream is1) {
                try (InputStream is = is1) {
                    createGraph(is);
                    return null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        if (ant)
            visitAntProject(fileVisitor);
        else
            visitProjectDir(fileVisitor);
        scanSuspendablesFile(fileVisitor);
        final long tBuildGraph = System.nanoTime();
        log("Built method graph in " + (tBuildGraph - tScanExternal) / 1000000 + " ms", Project.MSG_INFO);
        walkGraph();
        final long tWalkGraph = System.nanoTime();
        log("Walked method graph in " + (tWalkGraph - tBuildGraph) / 1000000 + " ms", Project.MSG_INFO);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

Example 7 with AntClassLoader

use of org.apache.tools.ant.AntClassLoader in project randomizedtesting by randomizedtesting.

the class JUnit4 method execute.

@Override
public void execute() throws BuildException {
    validateJUnit4();
    validateArguments();
    // Initialize random if not already provided.
    if (random == null) {
        this.random = MoreObjects.firstNonNull(Strings.emptyToNull(getProject().getProperty(SYSPROP_RANDOM_SEED())), SeedUtils.formatSeed(new Random().nextLong()));
    }
    masterSeed();
    // Say hello and continue.
    log("<JUnit4> says " + RandomPicks.randomFrom(new Random(masterSeed()), WELCOME_MESSAGES) + " Master seed: " + getSeed(), Project.MSG_INFO);
    // Pass the random seed property.
    createJvmarg().setValue("-D" + SYSPROP_PREFIX() + "=" + CURRENT_PREFIX());
    createJvmarg().setValue("-D" + SYSPROP_RANDOM_SEED() + "=" + random);
    // Resolve paths first.
    this.classpath = resolveFiles(classpath);
    this.bootclasspath = resolveFiles(bootclasspath);
    getCommandline().createClasspath(getProject()).add(classpath);
    getCommandline().createBootclasspath(getProject()).add(bootclasspath);
    // Setup a class loader over test classes. This will be used for loading annotations
    // and referenced classes. This is kind of ugly, but mirroring annotation content will
    // be even worse and Description carries these.
    // TODO: [GH-211] we should NOT be using any actual classes, annotations, etc. 
    // from client code. Everything should be a mirror.
    testsClassLoader = new AntClassLoader(this.getClass().getClassLoader(), getProject(), getCommandline().getClasspath(), true);
    // Pass method filter if any.
    String testMethodFilter = Strings.emptyToNull(getProject().getProperty(SYSPROP_TESTMETHOD()));
    if (testMethodFilter != null) {
        Environment.Variable v = new Environment.Variable();
        v.setKey(SYSPROP_TESTMETHOD());
        v.setValue(testMethodFilter);
        getCommandline().addSysproperty(v);
    }
    // Process test classes and resources.
    long start = System.currentTimeMillis();
    final TestsCollection testCollection = processTestResources();
    final EventBus aggregatedBus = new EventBus("aggregated");
    final TestsSummaryEventListener summaryListener = new TestsSummaryEventListener();
    aggregatedBus.register(summaryListener);
    for (Object o : listeners) {
        if (o instanceof ProjectComponent) {
            ((ProjectComponent) o).setProject(getProject());
        }
        if (o instanceof AggregatedEventListener) {
            ((AggregatedEventListener) o).setOuter(this);
        }
        aggregatedBus.register(o);
    }
    if (testCollection.testClasses.isEmpty()) {
        aggregatedBus.post(new AggregatedQuitEvent());
    } else {
        start = System.currentTimeMillis();
        // reports) will have a problem with duplicate suite names, for example.
        if (uniqueSuiteNames) {
            testCollection.onlyUniqueSuiteNames();
        }
        final int jvmCount = determineForkedJvmCount(testCollection);
        final List<ForkedJvmInfo> slaveInfos = new ArrayList<>();
        for (int jvmid = 0; jvmid < jvmCount; jvmid++) {
            final ForkedJvmInfo slaveInfo = new ForkedJvmInfo(jvmid, jvmCount);
            slaveInfos.add(slaveInfo);
        }
        if (jvmCount > 1 && uniqueSuiteNames && testCollection.hasReplicatedSuites()) {
            throw new BuildException(String.format(Locale.ROOT, "There are test suites that request JVM replication and the number of forked JVMs %d is larger than 1. Run on a single JVM.", jvmCount));
        }
        // Prepare a pool of suites dynamically dispatched to slaves as they become idle.
        final Deque<String> stealingQueue = new ArrayDeque<String>(loadBalanceSuites(slaveInfos, testCollection, balancers));
        aggregatedBus.register(new Object() {

            @Subscribe
            public void onSlaveIdle(SlaveIdle slave) {
                if (stealingQueue.isEmpty()) {
                    slave.finished();
                } else {
                    String suiteName = stealingQueue.pop();
                    slave.newSuite(suiteName);
                }
            }
        });
        // Check for filtering expressions.
        Vector<Variable> vv = getCommandline().getSystemProperties().getVariablesVector();
        for (Variable v : vv) {
            if (SysGlobals.SYSPROP_TESTFILTER().equals(v.getKey())) {
                try {
                    Node root = new FilterExpressionParser().parse(v.getValue());
                    log("Parsed test filtering expression: " + root.toExpression(), Project.MSG_INFO);
                } catch (Exception e) {
                    log("Could not parse filtering expression: " + v.getValue(), e, Project.MSG_WARN);
                }
            }
        }
        // Create callables for the executor.
        final List<Callable<Void>> slaves = new ArrayList<>();
        for (int slave = 0; slave < jvmCount; slave++) {
            final ForkedJvmInfo slaveInfo = slaveInfos.get(slave);
            slaves.add(new Callable<Void>() {

                @Override
                public Void call() throws Exception {
                    executeSlave(slaveInfo, aggregatedBus);
                    return null;
                }
            });
        }
        ExecutorService executor = Executors.newCachedThreadPool();
        aggregatedBus.post(new AggregatedStartEvent(slaves.size(), // TODO: this doesn't account for replicated suites.
        testCollection.testClasses.size()));
        try {
            List<Future<Void>> all = executor.invokeAll(slaves);
            executor.shutdown();
            for (int i = 0; i < slaves.size(); i++) {
                Future<Void> f = all.get(i);
                try {
                    f.get();
                } catch (ExecutionException e) {
                    slaveInfos.get(i).executionError = e.getCause();
                }
            }
        } catch (InterruptedException e) {
            log("Master interrupted? Weird.", Project.MSG_ERR);
        }
        aggregatedBus.post(new AggregatedQuitEvent());
        for (ForkedJvmInfo si : slaveInfos) {
            if (si.start > 0 && si.end > 0) {
                log(String.format(Locale.ROOT, "JVM J%d: %8.2f .. %8.2f = %8.2fs", si.id, (si.start - start) / 1000.0f, (si.end - start) / 1000.0f, (si.getExecutionTime() / 1000.0f)), Project.MSG_INFO);
            }
        }
        log("Execution time total: " + Duration.toHumanDuration((System.currentTimeMillis() - start)));
        ForkedJvmInfo slaveInError = null;
        for (ForkedJvmInfo i : slaveInfos) {
            if (i.executionError != null) {
                log("ERROR: JVM J" + i.id + " ended with an exception, command line: " + i.getCommandLine());
                log("ERROR: JVM J" + i.id + " ended with an exception: " + Throwables.getStackTraceAsString(i.executionError), Project.MSG_ERR);
                if (slaveInError == null) {
                    slaveInError = i;
                }
            }
        }
        if (slaveInError != null) {
            throw new BuildException("At least one slave process threw an exception, first: " + slaveInError.executionError.getMessage(), slaveInError.executionError);
        }
    }
    final TestsSummary testsSummary = summaryListener.getResult();
    if (printSummary) {
        log("Tests summary: " + testsSummary, Project.MSG_INFO);
    }
    if (!testsSummary.isSuccessful()) {
        if (!Strings.isNullOrEmpty(failureProperty)) {
            getProject().setNewProperty(failureProperty, "true");
        }
        if (haltOnFailure) {
            throw new BuildException(String.format(Locale.ROOT, "There were test failures: %s [seed: %s]", testsSummary, getSeed()));
        }
    }
    if (!leaveTemporary) {
        for (Path f : temporaryFiles) {
            try {
                if (f != null) {
                    try {
                        Files.delete(f);
                    } catch (DirectoryNotEmptyException e) {
                        throw new DirectoryNotEmptyException("Remaining files: " + listFiles(f));
                    }
                }
            } catch (IOException e) {
                log("Could not remove temporary path: " + f.toAbsolutePath() + " (" + e + ")", e, Project.MSG_WARN);
            }
        }
    }
    if (statsPropertyPrefix != null) {
        Project p = getProject();
        p.setNewProperty(statsPropertyPrefix + ".tests", Integer.toString(testsSummary.tests));
        p.setNewProperty(statsPropertyPrefix + ".errors", Integer.toString(testsSummary.errors));
        p.setNewProperty(statsPropertyPrefix + ".failures", Integer.toString(testsSummary.failures));
        p.setNewProperty(statsPropertyPrefix + ".ignores", Integer.toString(testsSummary.ignores));
        p.setNewProperty(statsPropertyPrefix + ".suites", Integer.toString(testsSummary.suites));
        p.setNewProperty(statsPropertyPrefix + ".assumptions", Integer.toString(testsSummary.assumptions));
        p.setNewProperty(statsPropertyPrefix + ".suiteErrors", Integer.toString(testsSummary.suiteErrors));
        p.setNewProperty(statsPropertyPrefix + ".nonIgnored", Integer.toString(testsSummary.getNonIgnoredTestsCount()));
        p.setNewProperty(statsPropertyPrefix + ".successful", Boolean.toString(testsSummary.isSuccessful()));
    }
    int executedTests = testsSummary.getNonIgnoredTestsCount();
    if (executedTests == 0) {
        String message = "There were no executed tests: " + testsSummary;
        switch(ifNoTests) {
            case FAIL:
                throw new BuildException(message);
            case WARN:
                log(message, Project.MSG_WARN);
                break;
            case IGNORE:
                break;
            default:
                throw new RuntimeException("Unreachable case clause: " + ifNoTests);
        }
    }
}

Example 8 with AntClassLoader

use of org.apache.tools.ant.AntClassLoader in project groovy-core by groovy.

the class RootLoaderRef method execute.

public void execute() throws BuildException {
    if (taskClasspath == null || taskClasspath.size() == 0) {
        throw new BuildException("no classpath given");
    }
    Project project = getProject();
    AntClassLoader loader = new AntClassLoader(makeRoot(), true);
    project.addReference(name, loader);
}

Example 9 with AntClassLoader

use of org.apache.tools.ant.AntClassLoader in project flyway by flyway.

the class AbstractFlywayTask method prepareClassPath.

/**
     * Prepares the classpath this task runs in, so that it includes both the classpath for Flyway and the classpath for
     * the JDBC drivers and migrations.
     */
private void prepareClassPath() {
    Path classpath = (Path) getProject().getReference("flyway.classpath");
    if (classpath != null) {
        setClasspath(classpath);
    } else {
        Reference classpathRef = (Reference) getProject().getReference("flyway.classpathref");
        if (classpathRef != null) {
            setClasspathref(classpathRef);
        }
    }
    ClassLoader classLoader = new AntClassLoader(getClass().getClassLoader(), getProject(), classPath);
    Thread.currentThread().setContextClassLoader(classLoader);
}

Example 10 with AntClassLoader

use of org.apache.tools.ant.AntClassLoader in project error-prone by google.

the class ErrorProneAntCompilerAdapter method execute.

@Override
public boolean execute() throws BuildException {
    ClassLoader originalLoader = ErrorProneCompiler.class.getClassLoader();
    URL[] urls;
    if (originalLoader instanceof URLClassLoader) {
        urls = ((URLClassLoader) originalLoader).getURLs();
    } else if (originalLoader instanceof AntClassLoader) {
        String[] pieces = ((AntClassLoader) originalLoader).getClasspath().split(":");
        urls = new URL[pieces.length];
        for (int i = 0; i < pieces.length; ++i) {
            try {
                urls[i] = Paths.get(pieces[i]).toUri().toURL();
            } catch (MalformedURLException e) {
                throw new BuildException(e);
            }
        }
    } else {
        throw new BuildException("Unexpected ClassLoader: " + originalLoader.getClass());
    }
    ClassLoader loader = NonDelegatingClassLoader.create(ImmutableSet.<String>of(Function.class.getName()), urls, originalLoader);
    String[] args = setupModernJavacCommand().getArguments();
    try {
        Class<?> runnerClass = Class.forName(AntRunner.class.getName(), true, loader);
        @SuppressWarnings("unchecked") Function<String[], Boolean> runner = (Function<String[], Boolean>) runnerClass.newInstance();
        return runner.apply(args);
    } catch (ReflectiveOperationException e) {
        throw new LinkageError("Unable to create runner.", e);
    }
}