From dd8b5f45ddc0d1693ab7132c14f02e2d2d09c850 Mon Sep 17 00:00:00 2001 From: Tomas Zezula Date: Thu, 3 Mar 2016 12:56:40 +0100 Subject: [PATCH] Added module, modulepath attributes and modulepath, moduleupgradepath elements into Java task. --- src/etc/testcases/taskdefs/java.xml | 23 ++ .../org/apache/tools/ant/taskdefs/Java.java | 57 ++++- .../tools/ant/types/CommandlineJava.java | 228 +++++++++++++++++- .../apache/tools/ant/taskdefs/JavaTest.java | 88 ++++++- 4 files changed, 381 insertions(+), 15 deletions(-) diff --git a/src/etc/testcases/taskdefs/java.xml b/src/etc/testcases/taskdefs/java.xml index a0c0450b6..a3d377891 100644 --- a/src/etc/testcases/taskdefs/java.xml +++ b/src/etc/testcases/taskdefs/java.xml @@ -44,6 +44,9 @@ + + @@ -61,6 +64,26 @@ + + + + + + + + + + + + + + + + + + + + null if there is no module. + * @see #getJar() + * @see #getClassname() + * @since ??? + */ + public String getModule() { + if(executableType == ExecutableType.MODULE) { + return parseModuleFromModuleClassPair(javaCommand.getExecutable()); } return null; } @@ -382,6 +438,32 @@ public class CommandlineJava implements Cloneable { return bootclasspath; } + /** + * Create a modulepath. + * @param p the project to use to create the path. + * @return a path to be configured. + * @since ??? + */ + public Path createModulepath(Project p) { + if (modulepath == null) { + modulepath = new Path(p); + } + return modulepath; + } + + /** + * Create an upgrademodulepath. + * @param p the project to use to create the path. + * @return a path to be configured. + * @since ??? + */ + public Path createUpgrademodulepath(Project p) { + if (upgrademodulepath == null) { + upgrademodulepath = new Path(p); + } + return upgrademodulepath; + } + /** * Get the vm version. * @return the vm version. @@ -435,6 +517,18 @@ public class CommandlineJava implements Cloneable { listIterator.add( classpath.concatSystemClasspath("ignore").toString()); } + //module path + if (haveModulepath()) { + listIterator.add("-modulepath"); + listIterator.add( + modulepath.concatSystemClasspath("ignore").toString()); + } + //upgrade module path + if (haveUpgrademodulepath()) { + listIterator.add("-upgrademodulepath"); + listIterator.add( + upgrademodulepath.concatSystemClasspath("ignore").toString()); + } //now any assertions are added if (getAssertions() != null) { getAssertions().applyAssertions(listIterator); @@ -443,8 +537,10 @@ public class CommandlineJava implements Cloneable { // a bug in JDK < 1.4 that forces the jvm type to be specified as the first // option, it is appended here as specified in the docs even though there is // in fact no order. - if (executeJar) { + if (executableType == ExecutableType.JAR) { listIterator.add("-jar"); + } else if (executableType == ExecutableType.MODULE) { + listIterator.add("-m"); } // this is the classname to run as well as its arguments. // in case of 'executeJar', the executable is a jar file. @@ -531,7 +627,7 @@ public class CommandlineJava implements Cloneable { size++; } // jar execution requires an additional -jar option - if (executeJar) { + if (executableType == ExecutableType.JAR || executableType == ExecutableType.MODULE) { size++; } //assertions take up space too @@ -573,6 +669,24 @@ public class CommandlineJava implements Cloneable { return bootclasspath; } + /** + * Get the modulepath. + * @return modulepath or null. + * @since ??? + */ + public Path getModulepath() { + return modulepath; + } + + /** + * Get the upgrademodulepath. + * @return upgrademodulepath or null. + * @since ??? + */ + public Path getUpgrademodulepath() { + return upgrademodulepath; + } + /** * Cache current system properties and set them to those in this * Java command. @@ -617,6 +731,12 @@ public class CommandlineJava implements Cloneable { if (bootclasspath != null) { c.bootclasspath = (Path) bootclasspath.clone(); } + if (modulepath != null) { + c.modulepath = (Path) modulepath.clone(); + } + if (upgrademodulepath != null) { + c.upgrademodulepath = (Path) upgrademodulepath.clone(); + } if (assertions != null) { c.assertions = (Assertions) assertions.clone(); } @@ -660,6 +780,30 @@ public class CommandlineJava implements Cloneable { return calculateBootclasspath(log).size() > 0; } + /** + * Determine whether the modulepath has been specified. + * @return true if the modulepath is to be used. + * @since ??? + */ + public boolean haveModulepath() { + Path fullClasspath = modulepath != null + ? modulepath.concatSystemClasspath("ignore") : null; + return fullClasspath != null + && fullClasspath.toString().trim().length() > 0; + } + + /** + * Determine whether the upgrademodulepath has been specified. + * @return true if the upgrademodulepath is to be used. + * @since ??? + */ + public boolean haveUpgrademodulepath() { + Path fullClasspath = upgrademodulepath != null + ? upgrademodulepath.concatSystemClasspath("ignore") : null; + return fullClasspath != null + && fullClasspath.toString().trim().length() > 0; + } + /** * Calculate the bootclasspath based on the bootclasspath * specified, the build.sysclasspath and ant.build.clonevm magic @@ -696,4 +840,66 @@ public class CommandlineJava implements Cloneable { return cloneVm || "true".equals(System.getProperty("ant.build.clonevm")); } + + /** + * Creates JDK 9 main module command line argument. + * @param module the module name. + * @param classname the classname or null. + * @return the main module with optional classname command line argument. + * @since ??? + */ + private static String createModuleClassPair(final String module, final String classname) { + return classname == null ? + module : + String.format("%s/%s", module, classname); //NOI18N + } + + /** + * Parses a module name from JDK 9 main module command line argument. + * @param moduleClassPair a module with optional classname or null. + * @return the module name or null. + * @since ??? + */ + private static String parseModuleFromModuleClassPair(final String moduleClassPair) { + if (moduleClassPair == null) { + return null; + } + final String[] moduleAndClass = moduleClassPair.split("/"); //NOI18N + return moduleAndClass[0]; + } + + /** + * Parses a classname from JDK 9 main module command line argument. + * @param moduleClassPair a module with optional classname or null. + * @return the classname or null. + * @since ??? + */ + private static String parseClassFromModuleClassPair(final String moduleClassPair) { + if (moduleClassPair == null) { + return null; + } + final String[] moduleAndClass = moduleClassPair.split("/"); //NOI18N + return moduleAndClass.length == 2 ? + moduleAndClass[1] : + null; + } + + /** + * Type of execution. + * @since ??? + */ + private enum ExecutableType { + /** + * Main class execution. + */ + CLASS, + /** + * Jar file execution. + */ + JAR, + /** + * Module execution. + */ + MODULE + } } diff --git a/src/tests/junit/org/apache/tools/ant/taskdefs/JavaTest.java b/src/tests/junit/org/apache/tools/ant/taskdefs/JavaTest.java index d54b8f28e..8d9957180 100644 --- a/src/tests/junit/org/apache/tools/ant/taskdefs/JavaTest.java +++ b/src/tests/junit/org/apache/tools/ant/taskdefs/JavaTest.java @@ -41,6 +41,8 @@ import org.junit.Test; import org.junit.internal.AssumptionViolatedException; import static org.apache.tools.ant.AntAssert.assertContains; +import org.apache.tools.ant.types.Path; +import org.junit.Assert; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -118,10 +120,94 @@ public class JavaTest { buildRule.executeTarget("testClassnameAndJar"); fail("Build exception should have been thrown - both classname and JAR are not allowed"); } catch (BuildException ex) { - assertEquals("Cannot use 'jar' and 'classname' attributes in same command.", ex.getMessage()); + assertEquals("Cannot use 'jar' with 'classname' or 'module' attributes in same command.", ex.getMessage()); } } + @Test + public void testJarAndModule() { + try { + buildRule.executeTarget("testJarAndModule"); + fail("Build exception should have been thrown - both module and JAR are not allowed"); + } catch (BuildException ex) { + assertEquals("Cannot use 'jar' and 'module' attributes in same command", ex.getMessage()); + } + } + + @Test + public void testModuleAndJar() { + try { + buildRule.executeTarget("testModuleAndJar"); + fail("Build exception should have been thrown - both module and JAR are not allowed"); + } catch (BuildException ex) { + assertEquals("Cannot use 'jar' with 'classname' or 'module' attributes in same command.", ex.getMessage()); + } + } + + @Test + public void testClassnameAndModule() { + buildRule.executeTarget("testClassnameAndModule"); + } + + @Test + public void testModuleAndClassname() { + buildRule.executeTarget("testModuleAndClassname"); + } + + @Test + public void testModule() { + buildRule.executeTarget("testModule"); + } + + @Test + public void testModuleCommandLine() { + final String moduleName = "TestModule"; //NOI18N + final String arg = "appArg"; //NOI18N + final Java java = new Java(); + java.setFork(true); + java.setModule(moduleName); + java.setJvmargs("-Xmx128M"); + java.setArgs(arg); + final String[] cmdLine = java.getCommandLine().getCommandline(); + Assert.assertNotNull("Has command line.", cmdLine); + assertEquals("Command line should have 5 elements", 5, cmdLine.length); + assertEquals("Last command line element should be java argument: " + arg, + arg, + cmdLine[cmdLine.length-1]); + assertEquals("The command line element at index 3 should be module name: " + moduleName, + moduleName, + cmdLine[cmdLine.length-2]); + assertEquals("The command line element at index 2 should be -m", + "-m", + cmdLine[cmdLine.length-3]); + } + + @Test + public void testModuleAndClassnameCommandLine() { + final String moduleName = "TestModule"; //NOI18N + final String className = "org.apache.Test"; //NOI18N + final String moduleClassPair= String.format("%s/%s", moduleName, className); + final String arg = "appArg"; //NOI18N + final Java java = new Java(); + java.setFork(true); + java.setModule(moduleName); + java.setClassname(className); + java.setJvmargs("-Xmx128M"); //NOI18N + java.setArgs(arg); + final String[] cmdLine = java.getCommandLine().getCommandline(); + Assert.assertNotNull("Has command line.", cmdLine); + assertEquals("Command line should have 5 elements", 5, cmdLine.length); + assertEquals("Last command line element should be java argument: " + arg, + arg, + cmdLine[cmdLine.length-1]); + assertEquals("The command line element at index 3 should be module class pair: " + moduleClassPair, + moduleClassPair, + cmdLine[cmdLine.length-2]); + assertEquals("The command line element at index 2 should be -m", + "-m", + cmdLine[cmdLine.length-3]); + } + @Test public void testRun() { buildRule.executeTarget("testRun");