diff options
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java')
-rw-r--r-- | framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java | 398 |
1 files changed, 398 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java b/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java new file mode 100644 index 00000000..61504ad1 --- /dev/null +++ b/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTaskTest.java @@ -0,0 +1,398 @@ +/* + * 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()); + + + } + +} |