src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java - ant - Git at Google

 /*
  *  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
  *
  *      http://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.junit;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;

 import static org.apache.tools.ant.AntAssert.assertNotContains;
 import static org.apache.tools.ant.AntAssert.assertContains;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;

 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;

 import org.apache.tools.ant.BuildFileRule;
 import org.apache.tools.ant.util.JavaEnvUtils;
 import org.junit.Assume;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;

 public class JUnitTaskTest {

 	@Rule
 	public BuildFileRule buildRule = new BuildFileRule();

     /**
      * The JUnit setup method.
      */
 	@Before
     public void setUp() {
         buildRule.configureProject("src/etc/testcases/taskdefs/optional/junit.xml");
     }

 	@Test
     public void testCrash() {
     	buildRule.executeTarget("crash");
     	assertEquals("true", buildRule.getProject().getProperty("crashed"));
     }

 	@Test
     public void testNoCrash() {
     	buildRule.executeTarget("nocrash");
     	assertNull(buildRule.getProject().getProperty("crashed"));
     }

 	@Test
     public void testTimeout() {
     	buildRule.executeTarget("timeout");
     	assertEquals("true", buildRule.getProject().getProperty("timeout"));
     }

     @Test
     public void testNoTimeout() {
        buildRule.executeTarget("notimeout");
    	   assertNull(buildRule.getProject().getProperty("timeout"));
     }

     @Test
     public void testNonForkedCapture() throws IOException {
         buildRule.executeTarget("capture");
         assertNoPrint(buildRule.getLog(), "log");
         assertNoPrint(buildRule.getFullLog(), "debug log");
     }

     @Test
     public void testForkedCapture() throws IOException {
         buildRule.getProject().setProperty("fork", "true");
         testNonForkedCapture();
         // those would fail because of the way BuildFileRule captures output
         assertNoPrint(buildRule.getOutput(), "output");
         assertNoPrint(buildRule.getError(), "error output");
         assertOutput();
     }

     @Test
     public void testBatchTestForkOnceToDir() {
         assertResultFilesExist("testBatchTestForkOnceToDir", ".xml");
     }

     /** Bugzilla Report 32973 */
     @Test
     public void testBatchTestForkOnceExtension() {
         assertResultFilesExist("testBatchTestForkOnceExtension", ".foo");
     }


     /* Bugzilla Report 42984 */
     //TODO This scenario works from command line, but not from JUnit ...
     //     Running these steps from the junit.xml-directory work
     //     $ ant -f junit.xml failureRecorder.prepare
     //     $ ant -f junit.xml failureRecorder.runtest
     //     $ ant -f junit.xml failureRecorder.runtest
     //     $ ant -f junit.xml failureRecorder.fixing
     //     $ ant -f junit.xml failureRecorder.runtest
     //     $ ant -f junit.xml failureRecorder.runtest
     //     But running the JUnit testcase fails in 4th run.
     @Test
     public void testFailureRecorder() {
         if (JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.JAVA_1_5)) {
             try {
             	Class<?> clazz =Class.forName("junit.framework.JUnit4TestAdapter");
                 Assume.assumeFalse("Skipping test since it fails with JUnit 4", clazz != null);
             } catch (ClassNotFoundException e) {
                 // OK, this is JUnit3, can run test
             }
         }

         File testDir = new File(buildRule.getOutputDir(), "out");
         File collectorFile = new File(buildRule.getOutputDir(),
                 "out/FailedTests.java");

         // ensure that there is a clean test environment
         assertFalse("Test directory '" + testDir.getAbsolutePath()
                     + "' must not exist before the test preparation.",
                     testDir.exists());
         assertFalse("The collector file '"
                     + collectorFile.getAbsolutePath()
                     + "'must not exist before the test preparation.",
                     collectorFile.exists());


         // prepare the test environment
         buildRule.executeTarget("failureRecorder.prepare");
         assertTrue("Test directory '" + testDir.getAbsolutePath()
                    + "' was not created.", testDir.exists());
         assertTrue("There should be one class.",
                    (new File(testDir, "A.class")).exists());
         assertFalse("The collector file '"
                     + collectorFile.getAbsolutePath()
                     + "' should not exist before the 1st run.",
                     collectorFile.exists());


         // 1st junit run: should do all tests - failing and not failing tests
         buildRule.executeTarget("failureRecorder.runtest");
         assertTrue("The collector file '" + collectorFile.getAbsolutePath()
                    + "' should exist after the 1st run.",
                    collectorFile.exists());
         // the passing test cases
         buildRule.executeTarget("A.test01");
         assertContains("1st run: should run A.test01", buildRule.getOutput());
         buildRule.executeTarget("B.test05");
         assertContains("1st run: should run B.test05", buildRule.getOutput());
         buildRule.executeTarget("B.test06");
         assertContains("1st run: should run B.test06", buildRule.getOutput());
         buildRule.executeTarget("C.test07");
         assertContains("1st run: should run C.test07", buildRule.getOutput());
         buildRule.executeTarget("C.test08");
         assertContains("1st run: should run C.test08", buildRule.getOutput());
         buildRule.executeTarget("C.test09");
         assertContains("1st run: should run C.test09", buildRule.getOutput());
         // the failing test cases
         buildRule.executeTarget("A.test02");
         assertContains("1st run: should run A.test02", buildRule.getOutput());
         buildRule.executeTarget("A.test03");
         assertContains("1st run: should run A.test03", buildRule.getOutput());
         buildRule.executeTarget("B.test04");
         assertContains("1st run: should run B.test04", buildRule.getOutput());
         buildRule.executeTarget("D.test10");
         assertContains("1st run: should run D.test10", buildRule.getOutput());


         // 2nd junit run: should do only failing tests
         buildRule.executeTarget("failureRecorder.runtest");
         assertTrue("The collector file '" + collectorFile.getAbsolutePath()
                    + "' should exist after the 2nd run.",
                    collectorFile.exists());
         // the passing test cases
         buildRule.executeTarget("A.test01");
         assertNotContains("2nd run: should not run A.test01", buildRule.getOutput());
         buildRule.executeTarget("B.test05");
         assertNotContains("2nd run: should not run A.test05", buildRule.getOutput());
         buildRule.executeTarget("B.test06");
         assertNotContains("2nd run: should not run B.test06", buildRule.getOutput());
         buildRule.executeTarget("C.test07");
         assertNotContains("2nd run: should not run C.test07", buildRule.getOutput());
         buildRule.executeTarget("C.test08");
         assertNotContains("2nd run: should not run C.test08", buildRule.getOutput());
         buildRule.executeTarget("C.test09");
         assertNotContains("2nd run: should not run C.test09", buildRule.getOutput());
         // the failing test cases
         buildRule.executeTarget("A.test02");
         assertContains("2nd run: should run A.test02", buildRule.getOutput());
         buildRule.executeTarget("A.test03");
         assertContains("2nd run: should run A.test03", buildRule.getOutput());
         buildRule.executeTarget("B.test04");
         assertContains("2nd run: should run B.test04", buildRule.getOutput());
         buildRule.executeTarget("D.test10");
         assertContains("2nd run: should run D.test10", buildRule.getOutput());


         // "fix" errors in class A
         buildRule.executeTarget("failureRecorder.fixing");

         // 3rd run: four running tests with two errors
         buildRule.executeTarget("failureRecorder.runtest");
         assertTrue("The collector file '" + collectorFile.getAbsolutePath()
                    + "' should exist after the 3rd run.",
                    collectorFile.exists());
         buildRule.executeTarget("A.test02");
         assertContains("3rd run: should run A.test02", buildRule.getOutput());
         buildRule.executeTarget("A.test03");
         assertContains("3rd run: should run A.test03", buildRule.getOutput());
         buildRule.executeTarget("B.test04");
         assertContains("3rd run: should run B.test04", buildRule.getOutput());
         buildRule.executeTarget("D.test10");
         assertContains("3rd run: should run D.test10", buildRule.getOutput());


         // 4rd run: two running tests with errors
         buildRule.executeTarget("failureRecorder.runtest");
         assertTrue("The collector file '" + collectorFile.getAbsolutePath()
                    + "' should exist after the 4th run.",
                    collectorFile.exists());
         //TODO: these two statements fail
         //buildRule.executeTarget("A.test02");assertNotContains("4th run: should not run A.test02", buildRule.getOutput());
         //buildRule.executeTarget("A.test03");assertNotContains("4th run: should not run A.test03", buildRule.getOutput());
         buildRule.executeTarget("B.test04");
         assertContains("4th run: should run B.test04", buildRule.getOutput());
         buildRule.executeTarget("D.test10");
         assertContains("4th run: should run D.test10", buildRule.getOutput());

     }

     @Test
     public void testBatchTestForkOnceCustomFormatter() {
         assertResultFilesExist("testBatchTestForkOnceCustomFormatter", "foo");
     }

     // Bugzilla Issue 45411
     @Test
     public void testMultilineAssertsNoFork() {
         buildRule.executeTarget("testMultilineAssertsNoFork");
         assertNotContains("messaged up", buildRule.getLog());
         assertNotContains("crashed)", buildRule.getLog());
     }

     // Bugzilla Issue 45411
     @Test
     public void testMultilineAssertsFork() {
         buildRule.executeTarget("testMultilineAssertsFork");
         assertNotContains("messaged up", buildRule.getLog());
         assertNotContains("crashed)", buildRule.getLog());
     }

     private void assertResultFilesExist(String target, String extension) {
         buildRule.executeTarget(target);
         assertResultFileExists("JUnitClassLoader", extension);
         assertResultFileExists("JUnitTestRunner", extension);
         assertResultFileExists("JUnitVersionHelper", extension);
     }

     private void assertResultFileExists(String classNameFragment, String ext) {
         assertTrue("result for " + classNameFragment + "Test" + ext + " exists",

                    new File(buildRule.getOutputDir(), "TEST-org.apache.tools.ant."
                                             + "taskdefs.optional.junit."
                                             + classNameFragment + "Test" + ext)
                    .exists());
     }

     private void assertNoPrint(String result, String where) {
         assertNotContains(where + " '" + result + "' must not contain print statement",
                    "print to System.", result);
     }

     private void assertOutput() throws IOException {
         FileReader inner = new FileReader(new File(buildRule.getOutputDir(),
                                           "testlog.txt"));
         BufferedReader reader = new BufferedReader(inner);
         try {
             String line = reader.readLine();
             assertEquals("Testsuite: org.apache.tools.ant.taskdefs.optional.junit.Printer",
                          line);
             line = reader.readLine();
             assertNotNull(line);
             assertTrue(line.startsWith("Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed:"));
             line = reader.readLine();
             assertEquals("------------- Standard Output ---------------",
                          line);
             assertPrint(reader.readLine(), "static", "out");
             assertPrint(reader.readLine(), "constructor", "out");
             assertPrint(reader.readLine(), "method", "out");
             line = reader.readLine();
             assertEquals("------------- ---------------- ---------------",
                          line);
             line = reader.readLine();
             assertEquals("------------- Standard Error -----------------",
                          line);
             assertPrint(reader.readLine(), "static", "err");
             assertPrint(reader.readLine(), "constructor", "err");
             assertPrint(reader.readLine(), "method", "err");
             line = reader.readLine();
             assertEquals("------------- ---------------- ---------------",
                          line);
             line = reader.readLine();
             assertEquals("", line);
             line = reader.readLine();
             assertNotNull(line);
             assertTrue(line.startsWith("Testcase: testNoCrash took "));
         } finally {
             inner.close();
         }
     }

     private void assertPrint(String line, String from, String to) {
         String search = from + " print to System." + to;
         assertEquals(search, line);
     }

     @Test
     public void testJUnit4Skip() throws Exception {
         buildRule.executeTarget("testSkippableTests");

         DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.parse(new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit4Skippable.xml"));

         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));

     }

     @Test
     public void testTestMethods() throws Exception {
         buildRule.executeTarget("testTestMethods");
     }

     @Test
     public void testNonTestsSkipped() throws Exception {

         buildRule.executeTarget("testNonTests");
         assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.NonTestMissed.xml").exists());
         assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestMissed.xml").exists());
         assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.AbstractTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestMissed.xml").exists());
         assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.AbstractJUnit3TestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractJUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestWithSuiteNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestWithSuiteNotMissed.xml").exists());

         buildRule.executeTarget("testNonTestsRun");
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.NonTestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3NonTestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestNotMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractJUnit3TestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3NonTestMissed.xml").exists());
         assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestWithSuiteNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestWithSuiteNotMissed.xml").exists());


     }

 }
	/*
	* 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
	*
	* http://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.junit;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertTrue;

	import static org.apache.tools.ant.AntAssert.assertNotContains;
	import static org.apache.tools.ant.AntAssert.assertContains;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileReader;
	import java.io.IOException;

	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;

	import org.apache.tools.ant.BuildFileRule;
	import org.apache.tools.ant.util.JavaEnvUtils;
	import org.junit.Assume;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.w3c.dom.Document;
	import org.w3c.dom.Node;

	public class JUnitTaskTest {

	@Rule
	public BuildFileRule buildRule = new BuildFileRule();

	/**
	* The JUnit setup method.
	*/
	@Before
	public void setUp() {
	buildRule.configureProject("src/etc/testcases/taskdefs/optional/junit.xml");
	}

	@Test
	public void testCrash() {
	buildRule.executeTarget("crash");
	assertEquals("true", buildRule.getProject().getProperty("crashed"));
	}

	@Test
	public void testNoCrash() {
	buildRule.executeTarget("nocrash");
	assertNull(buildRule.getProject().getProperty("crashed"));
	}

	@Test
	public void testTimeout() {
	buildRule.executeTarget("timeout");
	assertEquals("true", buildRule.getProject().getProperty("timeout"));
	}

	@Test
	public void testNoTimeout() {
	buildRule.executeTarget("notimeout");
	assertNull(buildRule.getProject().getProperty("timeout"));
	}

	@Test
	public void testNonForkedCapture() throws IOException {
	buildRule.executeTarget("capture");
	assertNoPrint(buildRule.getLog(), "log");
	assertNoPrint(buildRule.getFullLog(), "debug log");
	}

	@Test
	public void testForkedCapture() throws IOException {
	buildRule.getProject().setProperty("fork", "true");
	testNonForkedCapture();
	// those would fail because of the way BuildFileRule captures output
	assertNoPrint(buildRule.getOutput(), "output");
	assertNoPrint(buildRule.getError(), "error output");
	assertOutput();
	}

	@Test
	public void testBatchTestForkOnceToDir() {
	assertResultFilesExist("testBatchTestForkOnceToDir", ".xml");
	}

	/** Bugzilla Report 32973 */
	@Test
	public void testBatchTestForkOnceExtension() {
	assertResultFilesExist("testBatchTestForkOnceExtension", ".foo");
	}


	/* Bugzilla Report 42984 */
	//TODO This scenario works from command line, but not from JUnit ...
	// Running these steps from the junit.xml-directory work
	// $ ant -f junit.xml failureRecorder.prepare
	// $ ant -f junit.xml failureRecorder.runtest
	// $ ant -f junit.xml failureRecorder.runtest
	// $ ant -f junit.xml failureRecorder.fixing
	// $ ant -f junit.xml failureRecorder.runtest
	// $ ant -f junit.xml failureRecorder.runtest
	// But running the JUnit testcase fails in 4th run.
	@Test
	public void testFailureRecorder() {
	if (JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.JAVA_1_5)) {
	try {
	Class<?> clazz =Class.forName("junit.framework.JUnit4TestAdapter");
	Assume.assumeFalse("Skipping test since it fails with JUnit 4", clazz != null);
	} catch (ClassNotFoundException e) {
	// OK, this is JUnit3, can run test
	}
	}

	File testDir = new File(buildRule.getOutputDir(), "out");
	File collectorFile = new File(buildRule.getOutputDir(),
	"out/FailedTests.java");

	// ensure that there is a clean test environment
	assertFalse("Test directory '" + testDir.getAbsolutePath()
	+ "' must not exist before the test preparation.",
	testDir.exists());
	assertFalse("The collector file '"
	+ collectorFile.getAbsolutePath()
	+ "'must not exist before the test preparation.",
	collectorFile.exists());


	// prepare the test environment
	buildRule.executeTarget("failureRecorder.prepare");
	assertTrue("Test directory '" + testDir.getAbsolutePath()
	+ "' was not created.", testDir.exists());
	assertTrue("There should be one class.",
	(new File(testDir, "A.class")).exists());
	assertFalse("The collector file '"
	+ collectorFile.getAbsolutePath()
	+ "' should not exist before the 1st run.",
	collectorFile.exists());


	// 1st junit run: should do all tests - failing and not failing tests
	buildRule.executeTarget("failureRecorder.runtest");
	assertTrue("The collector file '" + collectorFile.getAbsolutePath()
	+ "' should exist after the 1st run.",
	collectorFile.exists());
	// the passing test cases
	buildRule.executeTarget("A.test01");
	assertContains("1st run: should run A.test01", buildRule.getOutput());
	buildRule.executeTarget("B.test05");
	assertContains("1st run: should run B.test05", buildRule.getOutput());
	buildRule.executeTarget("B.test06");
	assertContains("1st run: should run B.test06", buildRule.getOutput());
	buildRule.executeTarget("C.test07");
	assertContains("1st run: should run C.test07", buildRule.getOutput());
	buildRule.executeTarget("C.test08");
	assertContains("1st run: should run C.test08", buildRule.getOutput());
	buildRule.executeTarget("C.test09");
	assertContains("1st run: should run C.test09", buildRule.getOutput());
	// the failing test cases
	buildRule.executeTarget("A.test02");
	assertContains("1st run: should run A.test02", buildRule.getOutput());
	buildRule.executeTarget("A.test03");
	assertContains("1st run: should run A.test03", buildRule.getOutput());
	buildRule.executeTarget("B.test04");
	assertContains("1st run: should run B.test04", buildRule.getOutput());
	buildRule.executeTarget("D.test10");
	assertContains("1st run: should run D.test10", buildRule.getOutput());


	// 2nd junit run: should do only failing tests
	buildRule.executeTarget("failureRecorder.runtest");
	assertTrue("The collector file '" + collectorFile.getAbsolutePath()
	+ "' should exist after the 2nd run.",
	collectorFile.exists());
	// the passing test cases
	buildRule.executeTarget("A.test01");
	assertNotContains("2nd run: should not run A.test01", buildRule.getOutput());
	buildRule.executeTarget("B.test05");
	assertNotContains("2nd run: should not run A.test05", buildRule.getOutput());
	buildRule.executeTarget("B.test06");
	assertNotContains("2nd run: should not run B.test06", buildRule.getOutput());
	buildRule.executeTarget("C.test07");
	assertNotContains("2nd run: should not run C.test07", buildRule.getOutput());
	buildRule.executeTarget("C.test08");
	assertNotContains("2nd run: should not run C.test08", buildRule.getOutput());
	buildRule.executeTarget("C.test09");
	assertNotContains("2nd run: should not run C.test09", buildRule.getOutput());
	// the failing test cases
	buildRule.executeTarget("A.test02");
	assertContains("2nd run: should run A.test02", buildRule.getOutput());
	buildRule.executeTarget("A.test03");
	assertContains("2nd run: should run A.test03", buildRule.getOutput());
	buildRule.executeTarget("B.test04");
	assertContains("2nd run: should run B.test04", buildRule.getOutput());
	buildRule.executeTarget("D.test10");
	assertContains("2nd run: should run D.test10", buildRule.getOutput());


	// "fix" errors in class A
	buildRule.executeTarget("failureRecorder.fixing");

	// 3rd run: four running tests with two errors
	buildRule.executeTarget("failureRecorder.runtest");
	assertTrue("The collector file '" + collectorFile.getAbsolutePath()
	+ "' should exist after the 3rd run.",
	collectorFile.exists());
	buildRule.executeTarget("A.test02");
	assertContains("3rd run: should run A.test02", buildRule.getOutput());
	buildRule.executeTarget("A.test03");
	assertContains("3rd run: should run A.test03", buildRule.getOutput());
	buildRule.executeTarget("B.test04");
	assertContains("3rd run: should run B.test04", buildRule.getOutput());
	buildRule.executeTarget("D.test10");
	assertContains("3rd run: should run D.test10", buildRule.getOutput());


	// 4rd run: two running tests with errors
	buildRule.executeTarget("failureRecorder.runtest");
	assertTrue("The collector file '" + collectorFile.getAbsolutePath()
	+ "' should exist after the 4th run.",
	collectorFile.exists());
	//TODO: these two statements fail
	//buildRule.executeTarget("A.test02");assertNotContains("4th run: should not run A.test02", buildRule.getOutput());
	//buildRule.executeTarget("A.test03");assertNotContains("4th run: should not run A.test03", buildRule.getOutput());
	buildRule.executeTarget("B.test04");
	assertContains("4th run: should run B.test04", buildRule.getOutput());
	buildRule.executeTarget("D.test10");
	assertContains("4th run: should run D.test10", buildRule.getOutput());

	}

	@Test
	public void testBatchTestForkOnceCustomFormatter() {
	assertResultFilesExist("testBatchTestForkOnceCustomFormatter", "foo");
	}

	// Bugzilla Issue 45411
	@Test
	public void testMultilineAssertsNoFork() {
	buildRule.executeTarget("testMultilineAssertsNoFork");
	assertNotContains("messaged up", buildRule.getLog());
	assertNotContains("crashed)", buildRule.getLog());
	}

	// Bugzilla Issue 45411
	@Test
	public void testMultilineAssertsFork() {
	buildRule.executeTarget("testMultilineAssertsFork");
	assertNotContains("messaged up", buildRule.getLog());
	assertNotContains("crashed)", buildRule.getLog());
	}

	private void assertResultFilesExist(String target, String extension) {
	buildRule.executeTarget(target);
	assertResultFileExists("JUnitClassLoader", extension);
	assertResultFileExists("JUnitTestRunner", extension);
	assertResultFileExists("JUnitVersionHelper", extension);
	}

	private void assertResultFileExists(String classNameFragment, String ext) {
	assertTrue("result for " + classNameFragment + "Test" + ext + " exists",

	new File(buildRule.getOutputDir(), "TEST-org.apache.tools.ant."
	+ "taskdefs.optional.junit."
	+ classNameFragment + "Test" + ext)
	.exists());
	}

	private void assertNoPrint(String result, String where) {
	assertNotContains(where + " '" + result + "' must not contain print statement",
	"print to System.", result);
	}

	private void assertOutput() throws IOException {
	FileReader inner = new FileReader(new File(buildRule.getOutputDir(),
	"testlog.txt"));
	BufferedReader reader = new BufferedReader(inner);
	try {
	String line = reader.readLine();
	assertEquals("Testsuite: org.apache.tools.ant.taskdefs.optional.junit.Printer",
	line);
	line = reader.readLine();
	assertNotNull(line);
	assertTrue(line.startsWith("Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed:"));
	line = reader.readLine();
	assertEquals("------------- Standard Output ---------------",
	line);
	assertPrint(reader.readLine(), "static", "out");
	assertPrint(reader.readLine(), "constructor", "out");
	assertPrint(reader.readLine(), "method", "out");
	line = reader.readLine();
	assertEquals("------------- ---------------- ---------------",
	line);
	line = reader.readLine();
	assertEquals("------------- Standard Error -----------------",
	line);
	assertPrint(reader.readLine(), "static", "err");
	assertPrint(reader.readLine(), "constructor", "err");
	assertPrint(reader.readLine(), "method", "err");
	line = reader.readLine();
	assertEquals("------------- ---------------- ---------------",
	line);
	line = reader.readLine();
	assertEquals("", line);
	line = reader.readLine();
	assertNotNull(line);
	assertTrue(line.startsWith("Testcase: testNoCrash took "));
	} finally {
	inner.close();
	}
	}

	private void assertPrint(String line, String from, String to) {
	String search = from + " print to System." + to;
	assertEquals(search, line);
	}

	@Test
	public void testJUnit4Skip() throws Exception {
	buildRule.executeTarget("testSkippableTests");

	DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
	DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
	Document doc = dBuilder.parse(new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit4Skippable.xml"));

	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));

	}

	@Test
	public void testTestMethods() throws Exception {
	buildRule.executeTarget("testTestMethods");
	}

	@Test
	public void testNonTestsSkipped() throws Exception {

	buildRule.executeTarget("testNonTests");
	assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.NonTestMissed.xml").exists());
	assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestMissed.xml").exists());
	assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.AbstractTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestMissed.xml").exists());
	assertFalse("Test result should not exist as test was skipped - TEST-org.example.junit.AbstractJUnit3TestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractJUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestWithSuiteNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestWithSuiteNotMissed.xml").exists());

	buildRule.executeTarget("testNonTestsRun");
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.NonTestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3NonTestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3TestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3TestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractTestNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractTestNotMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.AbstractJUnit3TestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.AbstractJUnit3TestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.JUnit3NonTestMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.JUnit3NonTestMissed.xml").exists());
	assertTrue("Test result should exist as test was not skipped - TEST-org.example.junit.TestWithSuiteNotMissed.xml", new File(buildRule.getOutputDir(), "TEST-org.example.junit.TestWithSuiteNotMissed.xml").exists());


	}

	}