| /* |
| * 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.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Set; |
| import java.util.TreeSet; |
| |
| 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.BuildException; |
| |
| import org.apache.tools.ant.BuildFileRule; |
| import org.apache.tools.ant.MagicNames; |
| import org.apache.tools.ant.Project; |
| import org.apache.tools.ant.taskdefs.launcher.CommandLauncher; |
| import org.apache.tools.ant.taskdefs.optional.junit.JUnitTask.ForkMode; |
| import org.apache.tools.ant.types.Path; |
| import org.apache.tools.ant.util.JavaEnvUtils; |
| import org.apache.tools.ant.util.LoaderUtils; |
| 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()); |
| |
| |
| } |
| |
| @Test(expected = BuildException.class) |
| public void testModulePathNeedsFork() throws Exception { |
| final Project project = new Project(); |
| project.init(); |
| JUnitTask task = new JUnitTask(); |
| task.setProject(project); |
| final Path p = new Path(project); |
| p.setPath("modules"); |
| task.createModulepath().add(p); |
| task.addTest(new JUnitTest("org.apache.tools.ant.taskdefs.optional.junit.TestTest")); |
| task.execute(); |
| } |
| |
| @Test(expected = BuildException.class) |
| public void testUpgradeModulePathNeedsFork() throws Exception { |
| final Project project = new Project(); |
| project.init(); |
| JUnitTask task = new JUnitTask(); |
| task.setProject(project); |
| final Path p = new Path(project); |
| p.setPath("modules"); |
| task.createUpgrademodulepath().add(p); |
| task.addTest(new JUnitTest("org.apache.tools.ant.taskdefs.optional.junit.TestTest")); |
| task.execute(); |
| } |
| |
| @Test |
| public void testJunitOnCpArguments() throws Exception { |
| final File tmp = new File(System.getProperty("java.io.tmpdir")); //NOI18N |
| final File workDir = new File(tmp, String.format("%s_testJCP%d", //NOI18N |
| getClass().getName(), |
| System.currentTimeMillis()/1000)); |
| workDir.mkdirs(); |
| try { |
| final File modulesDir = new File(workDir,"modules"); //NOI18N |
| modulesDir.mkdirs(); |
| |
| final Project project = new Project(); |
| project.init(); |
| project.setBaseDir(workDir); |
| final MockCommandLauncher mockProcLauncher = new MockCommandLauncher(); |
| project.addReference( |
| MagicNames.ANT_VM_LAUNCHER_REF_ID, |
| mockProcLauncher); |
| JUnitTask task = new JUnitTask(); |
| task.setDir(workDir); |
| task.setFork(true); |
| task.setProject(project); |
| final File junit = LoaderUtils.getResourceSource( |
| JUnitTask.class.getClassLoader(), |
| "junit/framework/Test.class"); //NOI18N |
| final Path cp = new Path(project); |
| cp.setPath(junit.getAbsolutePath()); |
| task.createClasspath().add(cp); |
| final Path mp = new Path(project); |
| mp.setPath(modulesDir.getName()); |
| task.createModulepath().add(mp); |
| task.addTest(new JUnitTest("org.apache.tools.ant.taskdefs.optional.junit.TestTest")); |
| task.execute(); |
| assertNotNull(mockProcLauncher.cmd); |
| String resCp = null; |
| String resMp = null; |
| Set<String> resExports = new TreeSet<>(); |
| for (int i = 1; i< mockProcLauncher.cmd.length; i++) { |
| if ("-classpath".equals(mockProcLauncher.cmd[i])) { //NOI18N |
| resCp = mockProcLauncher.cmd[++i]; |
| } else if ("-modulepath".equals(mockProcLauncher.cmd[i])) { //NOI18N |
| resMp = mockProcLauncher.cmd[++i]; |
| } else if (mockProcLauncher.cmd[i].startsWith("-XaddExports:")) { //NOI18N |
| resExports.add(mockProcLauncher.cmd[i]); |
| } else if (JUnitTestRunner.class.getName().equals(mockProcLauncher.cmd[i])) { |
| break; |
| } |
| } |
| assertTrue("No exports", resExports.isEmpty()); |
| assertEquals("Expected classpath", cp.toString(), resCp); |
| assertEquals("Expected modulepath", mp.toString(), resMp); |
| } finally { |
| delete(workDir); |
| } |
| } |
| |
| @Test |
| public void testJunitOnMpArguments() throws Exception { |
| final File tmp = new File(System.getProperty("java.io.tmpdir")); //NOI18N |
| final File workDir = new File(tmp, String.format("%s_testJMP%d", //NOI18N |
| getClass().getName(), |
| System.currentTimeMillis()/1000)); |
| workDir.mkdirs(); |
| try { |
| final File modulesDir = new File(workDir,"modules"); //NOI18N |
| modulesDir.mkdirs(); |
| |
| final Project project = new Project(); |
| project.init(); |
| project.setBaseDir(workDir); |
| final MockCommandLauncher mockProcLauncher = new MockCommandLauncher(); |
| project.addReference( |
| MagicNames.ANT_VM_LAUNCHER_REF_ID, |
| mockProcLauncher); |
| JUnitTask task = new JUnitTask(); |
| task.setDir(workDir); |
| task.setFork(true); |
| task.setProject(project); |
| final File junit = LoaderUtils.getResourceSource( |
| JUnitTask.class.getClassLoader(), |
| "junit/framework/Test.class"); //NOI18N |
| final Path mp = new Path(project); |
| mp.add(new Path(project, junit.getAbsolutePath())); |
| mp.add(new Path(project, modulesDir.getName())); |
| task.createModulepath().add(mp); |
| task.addTest(new JUnitTest("org.apache.tools.ant.taskdefs.optional.junit.TestTest")); //NOI18N |
| task.execute(); |
| assertNotNull(mockProcLauncher.cmd); |
| String resCp = null; |
| String resMp = null; |
| Set<String> resExports = new TreeSet<>(); |
| for (int i = 1; i< mockProcLauncher.cmd.length; i++) { |
| if ("-classpath".equals(mockProcLauncher.cmd[i])) { //NOI18N |
| resCp = mockProcLauncher.cmd[++i]; |
| } else if ("-modulepath".equals(mockProcLauncher.cmd[i])) { //NOI18N |
| resMp = mockProcLauncher.cmd[++i]; |
| } else if (mockProcLauncher.cmd[i].startsWith("-XaddExports:")) { //NOI18N |
| resExports.add(mockProcLauncher.cmd[i]); |
| } else if (JUnitTestRunner.class.getName().equals(mockProcLauncher.cmd[i])) { |
| break; |
| } |
| } |
| assertTrue("No exports", resExports.isEmpty()); |
| assertNull("No classpath", resCp); |
| assertEquals("Expected modulepath", mp.toString(), resMp); |
| } finally { |
| delete(workDir); |
| } |
| } |
| |
| private void delete(File f) { |
| if (f.isDirectory()) { |
| final File[] clds = f.listFiles(); |
| if (clds != null) { |
| for (File cld : clds) { |
| delete(cld); |
| } |
| } |
| } |
| f.delete(); |
| } |
| |
| private static final class MockCommandLauncher extends CommandLauncher { |
| private String[] cmd; |
| |
| @Override |
| public Process exec(Project project, String[] cmd, String[] env, File workingDir) throws IOException { |
| this.cmd = Arrays.copyOf(cmd, cmd.length); |
| return new MockProcess(); |
| } |
| |
| private static class MockProcess extends Process { |
| |
| @Override |
| public OutputStream getOutputStream() { |
| return new ByteArrayOutputStream(); |
| } |
| |
| @Override |
| public InputStream getInputStream() { |
| return new ByteArrayInputStream(new byte[0]); |
| } |
| |
| @Override |
| public InputStream getErrorStream() { |
| return new ByteArrayInputStream(new byte[0]); |
| } |
| |
| @Override |
| public int waitFor() throws InterruptedException { |
| return exitValue(); |
| } |
| |
| @Override |
| public int exitValue() { |
| return 0; |
| } |
| |
| @Override |
| public void destroy() { |
| } |
| } |
| } |
| } |
