Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Ant Source Code Files
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-src.zip. Unzip the source package file and go to the "src/main" sub-directory, you will see source code files.
Here is the list of Java source code files of the Apache Ant 1.10.10 in \Users\fyicenter\apache-ant-1.10.10\src\main:
✍: FYIcenter.com
⏎ org/apache/tools/ant/taskdefs/optional/junitlauncher/LauncherSupport.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.tools.ant.taskdefs.optional.junitlauncher; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.MagicNames; import org.apache.tools.ant.Project; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.LaunchDefinition; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.ListenerDefinition; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.NamedTest; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.SingleTestClass; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.TestClasses; import org.apache.tools.ant.taskdefs.optional.junitlauncher.confined.TestDefinition; import org.apache.tools.ant.util.FileUtils; import org.apache.tools.ant.util.KeepAliveOutputStream; import org.apache.tools.ant.util.LeadPipeInputStream; import org.junit.platform.engine.Filter; import org.junit.platform.engine.discovery.DiscoverySelectors; import org.junit.platform.launcher.EngineFilter; import org.junit.platform.launcher.Launcher; import org.junit.platform.launcher.LauncherDiscoveryRequest; import org.junit.platform.launcher.TagFilter; import org.junit.platform.launcher.TestExecutionListener; import org.junit.platform.launcher.TestIdentifier; import org.junit.platform.launcher.TestPlan; import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder; import org.junit.platform.launcher.core.LauncherFactory; import org.junit.platform.launcher.listeners.SummaryGeneratingListener; import org.junit.platform.launcher.listeners.TestExecutionSummary; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.io.PrintStream; import java.io.UncheckedIOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.text.NumberFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.concurrent.BlockingQueue; import java.util.concurrent.CountDownLatch; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; /** * Responsible for doing the real work involved in launching the JUnit platform * and passing it the relevant tests that need to be executed by the JUnit platform. * <p> * This class relies on a {@link LaunchDefinition} for setting up the launch of the * JUnit platform. * <p> * The {@code LauncherSupport} isn't concerned with whether or not * it's being executed in the same JVM as the build in which the {@code junitlauncher} * was triggered or if it's running as part of a forked JVM. Instead it just relies * on the {@code LaunchDefinition} to do whatever decisions need to be done before and * after launching the tests. * <p> * This class is not thread-safe and isn't expected to be used for launching from * multiple different threads simultaneously. * <p>This class is an internal implementation detail of the Ant project and although * it's a public class, it isn't meant to be used outside of this project. This class * can be changed, across releases, without any backward compatible guarantees and hence * shouldn't be used or relied upon outside of this project. */ public class LauncherSupport { private final LaunchDefinition launchDefinition; private final TestExecutionContext testExecutionContext; private boolean testsFailed; /** * Create a {@link LauncherSupport} for the passed {@link LaunchDefinition} * * @param definition The launch definition which will be used for launching the tests * @param testExecutionContext The {@link TestExecutionContext} to use for the tests */ public LauncherSupport(final LaunchDefinition definition, final TestExecutionContext testExecutionContext) { if (definition == null) { throw new IllegalArgumentException("Launch definition cannot be null"); } if (testExecutionContext == null) { throw new IllegalArgumentException("Test execution context cannot be null"); } this.launchDefinition = definition; this.testExecutionContext = testExecutionContext; } /** * Launches the tests defined in the {@link LaunchDefinition} * * @throws BuildException If any tests failed and the launch definition was configured to throw * an exception, or if any other exception occurred before or after launching * the tests */ public void launch() throws BuildException { final ClassLoader previousClassLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(this.launchDefinition.getClassLoader()); final Launcher launcher = LauncherFactory.create(); final List<TestRequest> requests = buildTestRequests(); for (final TestRequest testRequest : requests) { try { final TestDefinition test = testRequest.getOwner(); final LauncherDiscoveryRequest request = testRequest.getDiscoveryRequest().build(); final List<TestExecutionListener> testExecutionListeners = new ArrayList<>(); // a listener that we always put at the front of list of listeners // for this request. final Listener firstListener = new Listener(System.out); // we always enroll the summary generating listener, to the request, so that we // get to use some of the details of the summary for our further decision making testExecutionListeners.add(firstListener); testExecutionListeners.addAll(getListeners(testRequest, this.launchDefinition.getClassLoader())); final PrintStream originalSysOut = System.out; final PrintStream originalSysErr = System.err; try { firstListener.switchedSysOutHandle = trySwitchSysOutErr(testRequest, StreamType.SYS_OUT, originalSysErr); firstListener.switchedSysErrHandle = trySwitchSysOutErr(testRequest, StreamType.SYS_ERR, originalSysErr); launcher.execute(request, testExecutionListeners.toArray(new TestExecutionListener[testExecutionListeners.size()])); } finally { // switch back sysout/syserr to the original try { System.setOut(originalSysOut); } catch (Exception e) { // ignore } try { System.setErr(originalSysErr); } catch (Exception e) { // ignore } // close the streams that we had used to redirect System.out/System.err try { firstListener.switchedSysOutHandle.ifPresent((h) -> { try { h.close(); } catch (Exception e) { // ignore } }); } catch (Exception e) { // ignore } try { firstListener.switchedSysErrHandle.ifPresent((h) -> { try { h.close(); } catch (Exception e) { // ignore } }); } catch (Exception e) { // ignore } } handleTestExecutionCompletion(test, firstListener.getSummary()); } finally { try { testRequest.close(); } catch (Exception e) { // log and move on log("Failed to cleanly close test request", e, Project.MSG_DEBUG); } } } } finally { Thread.currentThread().setContextClassLoader(previousClassLoader); } } /** * Returns true if there were any test failures, when this {@link LauncherSupport} was used * to {@link #launch()} tests. False otherwise. * * @return */ boolean hasTestFailures() { return this.testsFailed; } private List<TestRequest> buildTestRequests() { final List<TestDefinition> tests = this.launchDefinition.getTests(); if (tests.isEmpty()) { return Collections.emptyList(); } final List<TestRequest> requests = new ArrayList<>(); for (final TestDefinition test : tests) { final List<TestRequest> testRequests; if (test instanceof SingleTestClass || test instanceof TestClasses) { testRequests = createTestRequests(test); } else { throw new BuildException("Unexpected test definition type " + test.getClass().getName()); } if (testRequests == null || testRequests.isEmpty()) { continue; } requests.addAll(testRequests); } return requests; } private List<TestExecutionListener> getListeners(final TestRequest testRequest, final ClassLoader classLoader) { final TestDefinition test = testRequest.getOwner(); final List<ListenerDefinition> applicableListenerElements = test.getListeners().isEmpty() ? this.launchDefinition.getListeners() : test.getListeners(); final List<TestExecutionListener> listeners = new ArrayList<>(); final Optional<Project> project = this.testExecutionContext.getProject(); for (final ListenerDefinition applicableListener : applicableListenerElements) { if (project.isPresent() && !applicableListener.shouldUse(project.get())) { log("Excluding listener " + applicableListener.getClassName() + " since it's not applicable" + " in the context of project", null, Project.MSG_DEBUG); continue; } final TestExecutionListener listener = requireTestExecutionListener(applicableListener, classLoader); if (listener instanceof TestResultFormatter) { // setup/configure the result formatter setupResultFormatter(testRequest, applicableListener, (TestResultFormatter) listener); } listeners.add(listener); } return listeners; } private void setupResultFormatter(final TestRequest testRequest, final ListenerDefinition formatterDefinition, final TestResultFormatter resultFormatter) { testRequest.closeUponCompletion(resultFormatter); // set the execution context resultFormatter.setContext(this.testExecutionContext); resultFormatter.setUseLegacyReportingName(formatterDefinition.isUseLegacyReportingName()); // set the destination output stream for writing out the formatted result final java.nio.file.Path resultOutputFile = getListenerOutputFile(testRequest, formatterDefinition); try { final OutputStream resultOutputStream = Files.newOutputStream(resultOutputFile); // enroll the output stream to be closed when the execution of the TestRequest completes testRequest.closeUponCompletion(resultOutputStream); resultFormatter.setDestination(new KeepAliveOutputStream(resultOutputStream)); } catch (IOException e) { throw new BuildException(e); } // check if system.out/system.err content needs to be passed on to the listener if (formatterDefinition.shouldSendSysOut()) { testRequest.addSysOutInterest(resultFormatter); } if (formatterDefinition.shouldSendSysErr()) { testRequest.addSysErrInterest(resultFormatter); } } private Path getListenerOutputFile(final TestRequest testRequest, final ListenerDefinition listener) { final TestDefinition test = testRequest.getOwner(); final String filename; if (listener.getResultFile() != null) { filename = listener.getResultFile(); } else { // compute a file name final StringBuilder sb = new StringBuilder("TEST-"); sb.append(testRequest.getName() == null ? "unknown" : testRequest.getName()); sb.append("."); final String suffix; if ("org.apache.tools.ant.taskdefs.optional.junitlauncher.LegacyXmlResultFormatter".equals(listener.getClassName())) { suffix = "xml"; } else { suffix = "txt"; } sb.append(suffix); filename = sb.toString(); } if (listener.getOutputDir() != null) { // use the output dir defined on the listener return Paths.get(listener.getOutputDir(), filename); } // check on the enclosing test definition, in context of which this listener is being run if (test.getOutputDir() != null) { return Paths.get(test.getOutputDir(), filename); } // neither listener nor the test define a output dir, so use basedir of the project final TestExecutionContext testExecutionContext = this.testExecutionContext; final String baseDir = testExecutionContext.getProperties().getProperty(MagicNames.PROJECT_BASEDIR); return Paths.get(baseDir, filename); } private TestExecutionListener requireTestExecutionListener(final ListenerDefinition listener, final ClassLoader classLoader) { final String className = listener.getClassName(); if (className == null || className.trim().isEmpty()) { throw new BuildException("classname attribute value is missing on listener element"); } final Class<?> klass; try { klass = Class.forName(className, false, classLoader); } catch (ClassNotFoundException e) { throw new BuildException("Failed to load listener class " + className, e); } if (!TestExecutionListener.class.isAssignableFrom(klass)) { throw new BuildException("Listener class " + className + " is not of type " + TestExecutionListener.class.getName()); } try { return (TestExecutionListener) klass.getDeclaredConstructor().newInstance(); } catch (Exception e) { throw new BuildException("Failed to create an instance of listener " + className, e); } } private void handleTestExecutionCompletion(final TestDefinition test, final TestExecutionSummary summary) { final boolean hasTestFailures = summary.getTotalFailureCount() != 0; if (hasTestFailures) { // keep track of the test failure(s) for the entire launched instance this.testsFailed = true; } try { if (hasTestFailures && test.getFailureProperty() != null) { // if there are test failures and the test is configured to set a property in case // of failure, then set the property to true final TestExecutionContext testExecutionContext = this.testExecutionContext; if (testExecutionContext.getProject().isPresent()) { final Project project = testExecutionContext.getProject().get(); project.setNewProperty(test.getFailureProperty(), "true"); } } } finally { if (hasTestFailures && test.isHaltOnFailure()) { // if the test is configured to halt on test failures, throw a build error final String errorMessage; if (test instanceof NamedTest) { errorMessage = "Test " + ((NamedTest) test).getName() + " has " + summary.getTestsFailedCount() + " failure(s)"; } else { errorMessage = "Some test(s) have failure(s)"; } throw new BuildException(errorMessage); } } } private Optional<SwitchedStreamHandle> trySwitchSysOutErr(final TestRequest testRequest, final StreamType streamType, final PrintStream originalSysErr) { switch (streamType) { case SYS_OUT: { if (!testRequest.interestedInSysOut()) { return Optional.empty(); } break; } case SYS_ERR: { if (!testRequest.interestedInSysErr()) { return Optional.empty(); } break; } default: { // unknown, but no need to error out, just be lenient // and return back return Optional.empty(); } } final PipedOutputStream pipedOutputStream = new PipedOutputStream(); final PipedInputStream pipedInputStream; try { pipedInputStream = new LeadPipeInputStream(pipedOutputStream); } catch (IOException ioe) { // log and return return Optional.empty(); } final PrintStream printStream = new PrintStream(pipedOutputStream, true); final SysOutErrStreamReader streamer; switch (streamType) { case SYS_OUT: { System.setOut(new PrintStream(printStream)); streamer = new SysOutErrStreamReader(this, pipedInputStream, StreamType.SYS_OUT, testRequest.getSysOutInterests(), originalSysErr); final Thread sysOutStreamer = new Thread(streamer); sysOutStreamer.setDaemon(true); sysOutStreamer.setName("junitlauncher-sysout-stream-reader"); sysOutStreamer.setUncaughtExceptionHandler((t, e) -> { // skip the logging redirection infrastructure of junitlauncher task (which is what has // failed here) and instead directly write out the error to the original System.err originalSysErr.println("Failed in sysout streaming"); e.printStackTrace(originalSysErr); }); sysOutStreamer.start(); break; } case SYS_ERR: { System.setErr(new PrintStream(printStream)); streamer = new SysOutErrStreamReader(this, pipedInputStream, StreamType.SYS_ERR, testRequest.getSysErrInterests(), originalSysErr); final Thread sysErrStreamer = new Thread(streamer); sysErrStreamer.setDaemon(true); sysErrStreamer.setName("junitlauncher-syserr-stream-reader"); sysErrStreamer.setUncaughtExceptionHandler((t, e) -> { // skip the logging redirection infrastructure of junitlauncher task (which is what has // failed here) and instead directly write out the error to the original System.err originalSysErr.println("Failed in syserr streaming"); e.printStackTrace(originalSysErr); }); sysErrStreamer.start(); break; } default: { return Optional.empty(); } } return Optional.of(new SwitchedStreamHandle(pipedOutputStream, streamer)); } private void log(final String message, final Throwable t, final int level) { final TestExecutionContext testExecutionContext = this.testExecutionContext; if (testExecutionContext.getProject().isPresent()) { testExecutionContext.getProject().get().log(message, t, level); return; } if (t == null) { System.out.println(message); } else { System.err.println(message); t.printStackTrace(); } } private List<TestRequest> createTestRequests(final TestDefinition test) { // create TestRequest(s) and add necessary selectors, filters to it if (test instanceof SingleTestClass) { final SingleTestClass singleTestClass = (SingleTestClass) test; final LauncherDiscoveryRequestBuilder requestBuilder = LauncherDiscoveryRequestBuilder.request(); final TestRequest request = new TestRequest(test, requestBuilder); request.setName(singleTestClass.getName()); final String[] methods = singleTestClass.getMethods(); if (methods == null) { requestBuilder.selectors(DiscoverySelectors.selectClass(singleTestClass.getName())); } else { // add specific methods for (final String method : methods) { requestBuilder.selectors(DiscoverySelectors.selectMethod(singleTestClass.getName(), method)); } } addFilters(request); return Collections.singletonList(request); } if (test instanceof TestClasses) { final List<String> testClasses = ((TestClasses) test).getTestClassNames(); if (testClasses.isEmpty()) { return Collections.emptyList(); } final List<TestRequest> requests = new ArrayList<>(); for (final String testClass : testClasses) { final LauncherDiscoveryRequestBuilder requestBuilder = LauncherDiscoveryRequestBuilder.request(); final TestRequest request = new TestRequest(test, requestBuilder); request.setName(testClass); requestBuilder.selectors(DiscoverySelectors.selectClass(testClass)); addFilters(request); requests.add(request); } return requests; } return Collections.emptyList(); } /** * Add necessary {@link Filter JUnit filters} to the {@code testRequest} * * @param testRequest The test request */ private void addFilters(final TestRequest testRequest) { final LauncherDiscoveryRequestBuilder requestBuilder = testRequest.getDiscoveryRequest(); // add any engine filters final String[] enginesToInclude = testRequest.getOwner().getIncludeEngines(); if (enginesToInclude != null && enginesToInclude.length > 0) { requestBuilder.filters(EngineFilter.includeEngines(enginesToInclude)); } final String[] enginesToExclude = testRequest.getOwner().getExcludeEngines(); if (enginesToExclude != null && enginesToExclude.length > 0) { requestBuilder.filters(EngineFilter.excludeEngines(enginesToExclude)); } // add any tag filters if (this.launchDefinition.getIncludeTags().size() > 0) { requestBuilder.filters(TagFilter.includeTags(this.launchDefinition.getIncludeTags())); } if (this.launchDefinition.getExcludeTags().size() > 0) { requestBuilder.filters(TagFilter.excludeTags(this.launchDefinition.getExcludeTags())); } } private enum StreamType { SYS_OUT, SYS_ERR } // Implementation note: Logging from this class is prohibited since it can lead // to deadlocks (see bz-64733 for details) private static final class SysOutErrStreamReader implements Runnable { private static final byte[] EMPTY = new byte[0]; private final LauncherSupport launchManager; private final PrintStream originalSysErr; private final InputStream sourceStream; private final StreamType streamType; private final Collection<TestResultFormatter> resultFormatters; private volatile SysOutErrContentDeliverer contentDeliverer; SysOutErrStreamReader(final LauncherSupport launchManager, final InputStream source, final StreamType streamType, final Collection<TestResultFormatter> resultFormatters, final PrintStream originalSysErr) { this.launchManager = launchManager; this.sourceStream = source; this.streamType = streamType; this.resultFormatters = resultFormatters; this.originalSysErr = originalSysErr; } @Override public void run() { final SysOutErrContentDeliverer streamContentDeliver = new SysOutErrContentDeliverer(this.streamType, this.resultFormatters); final Thread deliveryThread = new Thread(streamContentDeliver); deliveryThread.setName("junitlauncher-" + (this.streamType == StreamType.SYS_OUT ? "sysout" : "syserr") + "-stream-deliverer"); deliveryThread.setDaemon(true); deliveryThread.start(); this.contentDeliverer = streamContentDeliver; int numRead = -1; final byte[] data = new byte[1024]; try { while ((numRead = this.sourceStream.read(data)) != -1) { final byte[] copy = Arrays.copyOf(data, numRead); streamContentDeliver.availableData.offer(copy); } } catch (IOException e) { // let the UncaughtExceptionHandler of this thread deal with this exception throw new UncheckedIOException(e); } finally { streamContentDeliver.stop = true; // just "wakeup" the delivery thread, to take into account // those race conditions, where that other thread didn't yet // notice that it was asked to stop and has now gone into a // X amount of wait, waiting for any new data streamContentDeliver.availableData.offer(EMPTY); } } } private static final class SysOutErrContentDeliverer implements Runnable { private volatile boolean stop; private final Collection<TestResultFormatter> resultFormatters; private final StreamType streamType; private final BlockingQueue<byte[]> availableData = new LinkedBlockingQueue<>(); private final CountDownLatch completionLatch = new CountDownLatch(1); SysOutErrContentDeliverer(final StreamType streamType, final Collection<TestResultFormatter> resultFormatters) { this.streamType = streamType; this.resultFormatters = resultFormatters; } @Override public void run() { try { while (!this.stop) { final byte[] streamData; try { streamData = this.availableData.poll(2, TimeUnit.SECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } if (streamData != null) { deliver(streamData); } } // drain it final List<byte[]> remaining = new ArrayList<>(); this.availableData.drainTo(remaining); if (!remaining.isEmpty()) { for (final byte[] data : remaining) { deliver(data); } } } finally { this.completionLatch.countDown(); } } private void deliver(final byte[] data) { if (data == null || data.length == 0) { return; } for (final TestResultFormatter resultFormatter : this.resultFormatters) { // send it to the formatter switch (streamType) { case SYS_OUT: { resultFormatter.sysOutAvailable(data); break; } case SYS_ERR: { resultFormatter.sysErrAvailable(data); break; } } } } } private final class SwitchedStreamHandle implements AutoCloseable { private final PipedOutputStream outputStream; private final SysOutErrStreamReader streamReader; SwitchedStreamHandle(final PipedOutputStream outputStream, final SysOutErrStreamReader streamReader) { this.streamReader = streamReader; this.outputStream = outputStream; } @Override public void close() throws Exception { outputStream.close(); streamReader.sourceStream.close(); } } private final class Listener extends SummaryGeneratingListener { private final PrintStream originalSysOut; private Optional<SwitchedStreamHandle> switchedSysOutHandle; private Optional<SwitchedStreamHandle> switchedSysErrHandle; private Listener(final PrintStream originalSysOut) { this.originalSysOut = originalSysOut; } @Override public void executionStarted(final TestIdentifier testIdentifier) { super.executionStarted(testIdentifier); AbstractJUnitResultFormatter.isTestClass(testIdentifier).ifPresent(testClass -> { this.originalSysOut.println("Running " + testClass.getClassName()); }); } private static final double ONE_SECOND = 1000.0; // We use this only in the testPlanExecutionFinished method, which // as per the JUnit5 platform semantics won't be called concurrently // by multiple threads (https://github.com/junit-team/junit5/issues/2539#issuecomment-766325555). // So it's safe to use this without any additional thread safety access controls. private NumberFormat timeFormatter = NumberFormat.getInstance(); @Override public void testPlanExecutionFinished(final TestPlan testPlan) { super.testPlanExecutionFinished(testPlan); if (!testPlan.containsTests()) { // we print the summary only if any tests are present return; } if (launchDefinition.isPrintSummary()) { final TestExecutionSummary summary = this.getSummary(); // Keep the summary as close to as the old junit task summary // tests run, failed, skipped, duration final StringBuilder sb = new StringBuilder("Tests run: "); sb.append(summary.getTestsStartedCount()); sb.append(", Failures: "); sb.append(summary.getTestsFailedCount()); sb.append(", Aborted: "); sb.append(summary.getTestsAbortedCount()); sb.append(", Skipped: "); sb.append(summary.getTestsSkippedCount()); sb.append(", Time elapsed: "); final long elapsedMs = summary.getTimeFinished() - summary.getTimeStarted(); sb.append(timeFormatter.format(elapsedMs / ONE_SECOND)); sb.append(" sec"); this.originalSysOut.println(sb.toString()); } // now that the test plan execution is finished, close the switched sysout/syserr output streams // and wait for the sysout and syserr content delivery, to result formatters, to finish if (this.switchedSysOutHandle.isPresent()) { final SwitchedStreamHandle sysOut = this.switchedSysOutHandle.get(); try { closeAndWait(sysOut); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } if (this.switchedSysErrHandle.isPresent()) { final SwitchedStreamHandle sysErr = this.switchedSysErrHandle.get(); try { closeAndWait(sysErr); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } private void closeAndWait(final SwitchedStreamHandle handle) throws InterruptedException { FileUtils.close(handle.outputStream); if (handle.streamReader.contentDeliverer == null) { return; } // wait for a few seconds handle.streamReader.contentDeliverer.completionLatch.await(2, TimeUnit.SECONDS); } } }
⏎ org/apache/tools/ant/taskdefs/optional/junitlauncher/LauncherSupport.java
Or download all of them as a single archive file:
File name: apache-ant-1.10.10-fyi.zip File size: 2392938 bytes Release date: 2021-04-17 Download
⇐ Download Apache Ant Source Package
2021-07-10, 109693👍, 0💬
Popular Posts:
io.jar is a component in iText Java library to provide input/output functionalities. iText Java libr...
How to run "jar" command from JDK tools.jar file? "jar" is the JAR (Java Archive) file management co...
What is the jaxp\SourceValidator.jav aprovided in the Apache Xerces package? I have Apache Xerces 2....
JSP(tm) Standard Tag Library 1.1 implementation - Jakarta Taglibs hosts the Standard Taglib 1.1, an ...
How to download and install javamail-1_2.zip? The JavaMail API is a set of abstract APIs that model ...