import junit.framework.JUnit4TestCaseFacade;

import org.junit.Ignore;

import org.junit.runner.Description;

import org.junit.runner.notification.Failure;

     * Tests that were skipped. This is a bit of a hack - tests are keyed by caseName(className) since

     * the Test we get for Test start isn't the same as the Test we get during test assumption fail,

     * so we can't easily match Test objects

     */

    private Hashtable<Description, Test> skippedTests = new Hashtable<Description, Test>();

    /**

     * Tests that were skipped. This is a bit of a hack - tests are keyed by caseName(className) since

     * the Test we get for Test start isn't the same as the Test we get during test assumption fail,

     * so we can't easily match Test objects

     */

    private Hashtable<Description, Test> ignoredTests = new Hashtable<Description, Test>();

    /**

        /* to bring the tests attribute inline with other runners (e.g. surefire), we actually include ignored tests in

         * the total test count

         * we have an issue where tests that were skipped due to Assumption failures are recorded as started despite not

         * producing a final result (pass, fail, error) so we subtract their count from the overall totals

         */

        rootElement.setAttribute(ATTR_SKIPPED, "" + suite.skipCount());

    private static Description createDescription(Test test) {

        return Description.createTestDescription(JUnitVersionHelper.getTestCaseClassName(test), JUnitVersionHelper.getTestCaseName(test));

    }

        Description testDescription = createDescription(test);

    @Override

    public void testIgnored(Test test) {

        String message = null;

        if (test != null) {

            if (test instanceof JUnit4TestCaseFacade) {

                JUnit4TestCaseFacade facade = (JUnit4TestCaseFacade) test;

                Ignore annotation = facade.getDescription().getAnnotation(Ignore.class);

                if (annotation != null && annotation.value() != null && !annotation.value().isEmpty()) {

                    message = annotation.value();

                }

            }

        }

        formatSkip(test, message);

        if (test != null) {

            ignoredTests.put(createDescription(test), test);

        }

    }

    public void formatSkip(Test test, String message) {

        if (test != null) {

            endTest(test);

        }

        Element nested = doc.createElement("skipped");

        if (message != null) {

            nested.setAttribute("message", message);

        }

        Element currentTest;

        if (test != null) {

            currentTest = testElements.get(createDescription(test));

        } else {

            currentTest = rootElement;

        }

        currentTest.appendChild(nested);

    }

    @Override

    public void testAssumptionFailure(Failure failure) {

        Test test = CustomJUnit4TestAdapterCache.getDefault().asTest(failure.getDescription());

        String message = failure.getMessage();

        formatSkip(test, message);

        skippedTests.put(createDescription(test), test);

    }

package org.apache.tools.ant.taskdefs.optional.junit;

import junit.framework.AssertionFailedError;

import junit.framework.JUnit4TestAdapterCache;

import junit.framework.Test;

import junit.framework.TestListener;

import org.junit.internal.AssumptionViolatedException;

import org.junit.runner.Description;

import org.junit.runner.notification.Failure;

import org.junit.runner.notification.RunListener;

public class TestListenerWrapper extends RunListener implements IgnoredTestListener {

    private TestListener wrapped;

    public TestListenerWrapper(TestListener listener) {

        super();

        wrapped = listener;

    }

    @Override

    public void addError(Test test, Throwable throwable) {

        wrapped.addError(test, throwable);

    }

    @Override

    public void addFailure(Test test, AssertionFailedError assertionFailedError) {

        wrapped.addFailure(test, assertionFailedError);

    }

    @Override

    public void endTest(Test test) {

        wrapped.endTest(test);

    }

    @Override

    public void startTest(Test test) {

        wrapped.startTest(test);

    }

    private static Test convertDescription(Description description) {

        return JUnit4TestAdapterCache.getDefault().asTest(description);

    }

    @Override

    public void testStarted(Description description) {

        startTest(convertDescription(description));

    }

    @Override

    public void testFinished(Description description) {

        endTest(convertDescription(description));

    }

    @Override

    public void testFailure(Failure failure) {

        if (failure.getException() instanceof AssertionFailedError) {

             addFailure(convertDescription(failure.getDescription()), (AssertionFailedError) failure.getException());

        } else if (failure.getException() instanceof AssumptionViolatedException) {

             testAssumptionFailure(failure);

        } else {

             addError(convertDescription(failure.getDescription()), failure.getException());

        }

    }

    @Override

    public void testIgnored(Description description) {

        testIgnored(convertDescription(description));

    }

    @Override

    public void testIgnored(Test test) {

        if (wrapped instanceof IgnoredTestListener) {

            ((IgnoredTestListener)wrapped).testIgnored(test);

        }

    }

    @Override

    public void testAssumptionFailure(Failure failure) {

        failure.getDescription();

        if (wrapped instanceof IgnoredTestListener) {

            ((IgnoredTestListener)wrapped).testAssumptionFailure(failure);

        }

    }

}

package org.apache.tools.ant.taskdefs.optional.junit;

import junit.framework.JUnit4TestAdapterCache;

import junit.framework.Test;

import junit.framework.TestListener;

import junit.framework.TestResult;

import org.junit.runner.notification.Failure;

import java.util.ArrayList;

import java.util.List;

/**

 * Records ignored and skipped tests reported as part of the execution of

 * JUnit 4 tests.

 *

 * @author Michael Clarke

 */

public class IgnoredTestResult extends TestResult {

    private List<IgnoredTestListener> listeners = new ArrayList<IgnoredTestListener>();

    private List<TestIgnored> ignored = new ArrayList<TestIgnored>();

    private List<TestIgnored> skipped = new ArrayList<TestIgnored>();

    public IgnoredTestResult() {

        super();

    }

    public synchronized void addListener(TestListener listener) {

        if (listener instanceof IgnoredTestListener) {

            listeners.add((IgnoredTestListener)listener);

        }

        super.addListener(listener);

    }

    public synchronized  void removeListener(TestListener listener) {

        if (listener instanceof IgnoredTestListener) {

            listeners.remove(listener);

        }

        super.removeListener(listener);

    }

    /**

     * Record a test as having been ignored, normally by the @Ignore annotation.

     * @param test the test that was ignored.

     * @throws Exception is the listener thrown an exception on handling the notification.

     */

    public synchronized void testIgnored(Test test) throws Exception {

        ignored.add(new TestIgnored(test));

        for (IgnoredTestListener listener : listeners) {

            listener.testIgnored(test);

        }

    }

    /**

     * Report how many tests were ignored.

     * @return the number of tests reported as ignored during the current execution.

     */

    public long ignoredCount() {

        return ignored.size();

    }

    /**

     * Records a test as having an assumption failure so JUnit will no longer be executing it.

     * Under normal circumstances this would be counted as a skipped test.

     * @param failure the details of the test and assumption failure.

     */

    public void testAssumptionFailure(Failure failure) {

        skipped.add(new TestIgnored(JUnit4TestAdapterCache.getDefault().asTest(failure.getDescription())));

        for (IgnoredTestListener listener : listeners) {

            listener.testAssumptionFailure(failure);

        }

    }

    /**

     * Report how many tests has assumption failures.

     * @return the number of tests that reported assumption failures during the current execution.

     */

    public long skippedCount() {

        return skipped.size();

    }

}

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathFactory;

    }

    public void testJunit4Skip() throws Exception {

        executeTarget("testSkippableTests");

        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();

        Document doc = dBuilder.parse(getProject().getResource("out/TEST-org.example.junit.Junit4Skippable.xml").getInputStream());

        assertEquals("Incorrect number of nodes created", 8, doc.getElementsByTagName("testcase").getLength());

        XPathFactory factory = XPathFactory.newInstance();

        XPath xpath = factory.newXPath();

        assertEquals("Incorrect number of skipped tests in header", 4, Integer.parseInt(xpath.compile("//testsuite/@skipped").evaluate(doc)));

        assertEquals("Incorrect number of error tests in header", 1, Integer.parseInt(xpath.compile("//testsuite/@errors").evaluate(doc)));

        assertEquals("Incorrect number of failure tests in header", 2, Integer.parseInt(xpath.compile("//testsuite/@failures").evaluate(doc)));

        assertEquals("Incorrect number of tests in header", 8, Integer.parseInt(xpath.compile("//testsuite/@tests").evaluate(doc)));

        assertEquals("Incorrect ignore message on explicit ignored test", "Please don't ignore me!", xpath.compile("//testsuite/testcase[@name='explicitIgnoreTest']/skipped/@message").evaluate(doc));

        assertEquals("No message should be set on Ignored tests with no Ignore annotation text", 0, ((Node)xpath.compile("//testsuite/testcase[@name='explicitlyIgnoreTestNoMessage']/skipped").evaluate(doc, XPathConstants.NODE)).getAttributes().getLength());

        assertEquals("Incorrect ignore message on implicit ignored test", "This test will be ignored", xpath.compile("//testsuite/testcase[@name='implicitlyIgnoreTest']/skipped/@message").evaluate(doc));

        assertNotNull("Implicit ignore test should have an ignore element", xpath.compile("//testsuite/testcase[@name='implicitlyIgnoreTestNoMessage']/skipped").evaluate(doc, XPathConstants.NODE));

        sb.append(", Skipped: ");

        sb.append(suite.skipCount());

    String ATTR_SKIPPED = "skipped";

package org.apache.tools.ant.taskdefs.optional.junit;

import junit.framework.Test;

public class TestIgnored {

    private Test test;

    public TestIgnored(Test test) {

        this.test = test;

    }

    public Test getTest() {

        return test;

    }

}

package org.apache.tools.ant.taskdefs.optional.junit;

import junit.framework.JUnit4TestAdapter;

import junit.framework.JUnit4TestAdapterCache;

import junit.framework.TestResult;

import org.junit.runner.Description;

import org.junit.runner.notification.Failure;

import org.junit.runner.notification.RunListener;

import org.junit.runner.notification.RunNotifier;

/**

 * Provides a custom implementation of the notifier for a Junit4TestAdapter

 * so that skipped and ignored tests can be reported to the existing

 * <tt></tt>TestListener</tt>s.

 *

 * @author Michael Clarke

 */

public class CustomJUnit4TestAdapterCache extends JUnit4TestAdapterCache {

    public CustomJUnit4TestAdapterCache() {

        super();

    }

    public RunNotifier getNotifier(final TestResult result, final JUnit4TestAdapter adapter) {

        if (!(result instanceof IgnoredTestResult)) {

            //the TestResult doesn't support our ignored method, continue with default functionality

            return super.getNotifier(result, adapter);

        }

        final IgnoredTestResult resultWrapper = (IgnoredTestResult) result;

        RunNotifier notifier = new RunNotifier();

        notifier.addListener(new RunListener() {

            @Override

            public void testFailure(Failure failure) throws Exception {

                result.addError(asTest(failure.getDescription()), failure.getException());

            }

            @Override

            public void testFinished(Description description) throws Exception {

                result.endTest(asTest(description));

            }

            @Override

            public void testStarted(Description description) throws Exception {

                resultWrapper.startTest(asTest(description));

            }

            @Override

            public void testIgnored(Description description) throws Exception {

                resultWrapper.testIgnored(asTest(description));

            }

            @Override

            public void testAssumptionFailure(Failure failure) {

                resultWrapper.testAssumptionFailure(failure);

            }

        });

        return notifier;

    }

}

  <!-- Junit4 Ignore and Assume for skipping tests -->

  <target name="testSkippableTests">

    <mkdir dir="out"/>

    <junit fork="true">

            <classpath refid="test"/>

            <formatter type="xml"/>

            <classpath refid="test"/>

            <batchtest todir="out">

                <fileset dir="../../../../tests/junit">

                    <include

                            name="org/example/junit/Junit4Skippable.java"/>

                    <!-- tests remove out-dir on tearDown -->

                </fileset>

            </batchtest>

    </junit>

  </target>

                    }

                    public void testIgnored(Description description) throws Exception {

                        if (result instanceof IgnoredTestResult) {

                            ((IgnoredTestResult)result).testIgnored(asTest(description));

                        }

import junit.framework.JUnit4TestCaseFacade;

import org.junit.Ignore;

import org.junit.runner.notification.Failure;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.OutputStream;

import java.io.StringWriter;

import java.text.NumberFormat;

        sb.append(", Skipped: ");

        sb.append(suite.skipCount());

    }

    @Override

    public void testIgnored(Test test) {

        String message = null;

        if (test instanceof JUnit4TestCaseFacade) {

            JUnit4TestCaseFacade facade = (JUnit4TestCaseFacade) test;

            Ignore annotation = facade.getDescription().getAnnotation(Ignore.class);

            if (annotation != null && annotation.value() != null && !annotation.value().isEmpty()) {

                message = annotation.value();

            }

        }

        formatSkip(test, message);

    }

    public void formatSkip(Test test, String message) {

        if (test != null) {

            endTest(test);

        }

        try {

            resultWriter.write(formatTest(test) + "SKIPPED");

            if (message != null) {

                resultWriter.write(": ");

                resultWriter.write(message);

            }

            resultWriter.newLine();

        } catch (IOException ex) {

            throw new BuildException(ex);

        }

    }

    @Override

    public void testAssumptionFailure(Failure failure) {

        String message = failure.getMessage();

        formatSkip(CustomJUnit4TestAdapterCache.getDefault().asTest(failure.getDescription()), message);

package org.example.junit;

import org.junit.Assume;

import org.junit.Ignore;

import org.junit.Test;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;

public class Junit4Skippable {

    @Test

    public void passingTest() {

        assertTrue("This test passed", true);

    }

    @Ignore("Please don't ignore me!")

    @Test

    public void explicitIgnoreTest() {

        fail("This test should be skipped");

    }

    @Test

    public void implicitlyIgnoreTest() {

        Assume.assumeFalse("This test will be ignored", true);

        fail("I told you, this test should have been ignored!");

    }

    @Test

    @Ignore

    public void explicitlyIgnoreTestNoMessage() {

        fail("This test should be skipped");

    }

    @Test

    public void implicitlyIgnoreTestNoMessage() {

        Assume.assumeFalse(true);

        fail("I told you, this test should have been ignored!");

    }

    @Test

    public void failingTest() {

        fail("I told you this test was going to fail");

    }

    @Test

    public void failingTestNoMessage() {

        fail();

    }

    @Test

    public void errorTest() {

        throw new RuntimeException("Whoops, this test went wrong");

    }

}

package org.apache.tools.ant.taskdefs.optional.junit;

import junit.framework.Test;

import junit.framework.TestListener;

import org.junit.runner.notification.Failure;

/**

 * Provides the functionality for TestListeners to be able to be notified of

 * the necessary Junit4 events for test being ignored (@Ignore annotation)

 * or skipped (Assume failures). Tests written in Junit4 will report against

 * the methods in this interface alongside the methods in the existing TestListener

 * @author Michael Clarke

 */

public interface IgnoredTestListener extends TestListener {

    /**

     * Reports when a test has been marked with the @Ignore annotation. The parameter

     * should normally be typed to Junit's {@link junit.framework.JUnit4TestCaseFacade}

     * so implementing classes should be able to get the details of the ignore by casting

     * the argument and retrieving the descriptor from the test.

     * @param test

     */

    void testIgnored(Test test);

    /**

     * Received a report that a test has failed an assumption. Within JUnit4

     * this is normally treated as a test being skipped, although how any

     * listener handles this is up to the listener's author.<br />

     * <b>Note:</b> Tests that throw assumption failures will still report

     * the endTest method, which may differ from the addError and addFailure methods,

     * it's up for any implementing classes to handle this.

     * @param failure the details of the test and failure that have triggered this report.

     */

    void testAssumptionFailure(Failure failure);

}

     * @params skips   the number of skipped tests.

        this.skips = skips;

    }

    /**

     * Get the number of skipped tests.

     * @return the number of skipped tests.

     */

    public long skipCount() {

        return skips;

import junit.framework.JUnit4TestCaseFacade;

import org.junit.Ignore;

import org.junit.runner.notification.Failure;

        sb.append(", Skipped: ");

        sb.append(suite.skipCount());

    @Override

    public void testIgnored(Test test) {

        String message = null;

        if (test instanceof JUnit4TestCaseFacade) {

            JUnit4TestCaseFacade facade = (JUnit4TestCaseFacade) test;

            Ignore annotation = facade.getDescription().getAnnotation(Ignore.class);

            if (annotation != null && annotation.value() != null && !annotation.value().isEmpty()) {

                message = annotation.value();

            }

        }

        formatSkip(test, message);

    }

    public void formatSkip(Test test, String message) {

        if (test != null) {

            endTest(test);

        }

        try {

            wri.write("\tSKIPPED");

            if (message != null) {

                wri.write(": ");

                wri.write(message);

            }

            wri.newLine();

        } catch (IOException ex) {

            throw new BuildException(ex);

        }

    }

    @Override

    public void testAssumptionFailure(Failure failure) {

        String message = failure.getMessage();

        formatSkip(CustomJUnit4TestAdapterCache.getDefault().asTest(failure.getDescription()), message);

    }

import junit.framework.JUnit4TestAdapterCache;

        super();