Examples with Parallel org.apache.tools.ant.taskdefs.Parallel used on opensource projects

Example 1 with Parallel

use of org.apache.tools.ant.taskdefs.Parallel in project ant by apache.

the class Funtest method newParallel.

/**
 * Create a newly bound parallel instance with one child
 * @param parallelTimeout timeout
 * @param child task
 * @return a bound and initialised parallel instance.
 */
private Parallel newParallel(long parallelTimeout, Task child) {
    Parallel par = newParallel(parallelTimeout);
    par.addTask(child);
    return par;
}

Example 2 with Parallel

use of org.apache.tools.ant.taskdefs.Parallel in project ant by apache.

the class Funtest method execute.

/**
 * Run the functional test sequence.
 * <p>
 * This is a fairly complex workflow -what is going on is that we try to clean up
 * no matter how the run ended, and to retain the innermost exception that got thrown
 * during cleanup. That is, if teardown fails after the tests themselves failed, it is the
 * test failing that is more important.
 * @throws BuildException if something was caught during the run or teardown.
 */
@Override
public void execute() throws BuildException {
    // validation
    validateTask(setup, "setup");
    validateTask(application, "application");
    validateTask(tests, "tests");
    validateTask(reporting, "reporting");
    validateTask(teardown, "teardown");
    // and bail out if it is defined but not true
    if (condition != null && !condition.eval()) {
        // we are skipping the test
        log(SKIPPING_TESTS);
        return;
    }
    long timeoutMillis = timeout * timeoutUnitMultiplier;
    // set up the application to run in a separate thread
    Parallel applicationRun = newParallel(timeoutMillis);
    // with a worker which we can use to manage it
    WorkerAnt worker = new WorkerAnt(applicationRun, null);
    if (application != null) {
        applicationRun.addTask(application);
    }
    // The test run consists of the block followed by the tests.
    long testRunTimeout = 0;
    Sequential testRun = new Sequential();
    bind(testRun);
    if (block != null) {
        // waitfor is not a task, it needs to be adapted
        TaskAdapter ta = new TaskAdapter(block);
        ta.bindToOwner(this);
        validateTask(ta, "block");
        testRun.addTask(ta);
        // add the block time to the total test run timeout
        testRunTimeout = block.calculateMaxWaitMillis();
    }
    // add the tests and more delay
    if (tests != null) {
        testRun.addTask(tests);
        testRunTimeout += timeoutMillis;
    }
    // add the reporting and more delay
    if (reporting != null) {
        testRun.addTask(reporting);
        testRunTimeout += timeoutMillis;
    }
    // wrap this in a parallel purely to set up timeouts for the
    // test run
    timedTests = newParallel(testRunTimeout, testRun);
    try {
        // run any setup task
        if (setup != null) {
            Parallel setupRun = newParallel(timeoutMillis, setup);
            setupRun.execute();
        }
        // start the worker thread and leave it running
        worker.start();
        // start the probe+test sequence
        timedTests.execute();
    } catch (BuildException e) {
        // Record the exception and continue
        testException = e;
    } finally {
        // teardown always runs; its faults are filed away
        if (teardown != null) {
            try {
                Parallel teardownRun = newParallel(timeoutMillis, teardown);
                teardownRun.execute();
            } catch (BuildException e) {
                teardownException = e;
            }
        }
    }
    try {
        // wait for the worker to have finished
        long shutdownTimeMillis = shutdownTime * shutdownUnitMultiplier;
        worker.waitUntilFinished(shutdownTimeMillis);
        if (worker.isAlive()) {
            // then, if it is still running, interrupt it a second time.
            log(APPLICATION_FORCIBLY_SHUT_DOWN, Project.MSG_WARN);
            worker.interrupt();
            worker.waitUntilFinished(shutdownTimeMillis);
        }
    } catch (InterruptedException e) {
        // success, something interrupted the shutdown. There may be a leaked
        // worker;
        log(SHUTDOWN_INTERRUPTED, e, Project.MSG_VERBOSE);
    }
    applicationException = worker.getBuildException();
    // Now faults are analysed
    processExceptions();
}

Example 3 with Parallel

use of org.apache.tools.ant.taskdefs.Parallel in project ant by apache.

the class Funtest method newParallel.

/**
 * Create a newly bound parallel instance
 * @param parallelTimeout timeout
 * @return a bound and initialised parallel instance.
 */
private Parallel newParallel(long parallelTimeout) {
    Parallel par = new Parallel();
    bind(par);
    par.setFailOnAny(true);
    par.setTimeout(parallelTimeout);
    return par;
}

Example 4 with Parallel

use of org.apache.tools.ant.taskdefs.Parallel in project ant-ivy by apache.

the class IvyResolveTest method disabledIVY1454.

/* disabled: Ivy is not thread-safe, and this usage is not supported at this time */
@Test
@Ignore
public void disabledIVY1454() {
    // run init in parent thread, then resolve in children
    project.setProperty("ivy.settings.file", "test/repositories/ivysettings-with-nio.xml");
    project.setProperty("ivy.log.locking", "true");
    resolve.setFile(new File("test/java/org/apache/ivy/ant/ivy-simple.xml"));
    Parallel parallel = new Parallel();
    parallel.setThreadCount(4);
    parallel.addTask(resolve);
    parallel.addTask(resolve);
    parallel.addTask(resolve);
    parallel.addTask(resolve);
    parallel.execute();
}