youys
/
ant
Not watched
1
0
Fork 1
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

ensure build.compiler works with full classnames for extjavac/modern 

https://bz.apache.org/bugzilla/show_bug.cgi?id=65539
master
Stefan Bodewig 4 years ago
parent
033f8dc250
commit
e5e0019a02
6 changed files with 256 additions and 111 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +8
    -0
      WHATSNEW
  2. +19
    -61
      src/main/org/apache/tools/ant/taskdefs/Javac.java
  3. +151
    -24
      src/main/org/apache/tools/ant/taskdefs/compilers/CompilerAdapterFactory.java
  4. +19
    -20
      src/main/org/apache/tools/ant/taskdefs/compilers/DefaultCompilerAdapter.java
  5. +10
    -2
      src/tests/junit/org/apache/tools/ant/taskdefs/JavacTest.java
  6. +49
    -4
      src/tests/junit/org/apache/tools/ant/taskdefs/compilers/DefaultCompilerAdapterTest.java

+ 8
- 0
WHATSNEW View File

@@ -1,6 +1,14 @@
Changes from Ant 1.9.16 TO Ant 1.9.17
=====================================

Fixed bugs:
-----------

* Made sure setting build.compiler to the fully qualified classname
that corresponds to extJavac or modern has the same effect as using
the shorter alias names.
Bugzilla Report 65539

Changes from Ant 1.9.15 TO Ant 1.9.16
=====================================



+ 19
- 61
src/main/org/apache/tools/ant/taskdefs/Javac.java View File

@@ -86,21 +86,6 @@ public class Javac extends MatchingTask {
private static final String FAIL_MSG
= "Compile failed; see the compiler error output for details.";

private static final String JAVAC10_PLUS = "javac10+";
private static final String JAVAC9 = "javac9";
private static final String JAVAC19 = "javac1.9";
private static final String JAVAC18 = "javac1.8";
private static final String JAVAC17 = "javac1.7";
private static final String JAVAC16 = "javac1.6";
private static final String JAVAC15 = "javac1.5";
private static final String JAVAC14 = "javac1.4";
private static final String JAVAC13 = "javac1.3";
private static final String JAVAC12 = "javac1.2";
private static final String JAVAC11 = "javac1.1";
private static final String MODERN = "modern";
private static final String CLASSIC = "classic";
private static final String EXTJAVAC = "extJavac";

private static final char GROUP_START_MARK = '{'; //modulesourcepath group start character
private static final char GROUP_END_MARK = '}'; //modulesourcepath group end character
private static final char GROUP_SEP_MARK = ','; //modulesourcepath group element separator character
@@ -162,21 +147,21 @@ public class Javac extends MatchingTask {

private String assumedJavaVersion() {
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4)) {
return JAVAC14;
return CompilerAdapterFactory.COMPILER_JAVAC_1_4;
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5)) {
return JAVAC15;
return CompilerAdapterFactory.COMPILER_JAVAC_1_5;
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6)) {
return JAVAC16;
return CompilerAdapterFactory.COMPILER_JAVAC_1_6;
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_7)) {
return JAVAC17;
return CompilerAdapterFactory.COMPILER_JAVAC_1_7;
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_8)) {
return JAVAC18;
return CompilerAdapterFactory.COMPILER_JAVAC_1_8;
} else if (JavaEnvUtils.isAtLeastJavaVersion("10")) {
return JAVAC10_PLUS;
return CompilerAdapterFactory.COMPILER_JAVAC_10_PLUS;
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_9)) {
return JAVAC9;
return CompilerAdapterFactory.COMPILER_JAVAC_9;
} else {
return CLASSIC;
return CompilerAdapterFactory.COMPILER_CLASSIC;
}
}

@@ -886,7 +871,7 @@ public class Javac extends MatchingTask {
* @return true if this is a forked invocation
*/
public boolean isForkedJavac() {
return fork || EXTJAVAC.equalsIgnoreCase(getCompiler());
return fork || CompilerAdapterFactory.isForkedJavac(getCompiler());
}

/**
@@ -965,38 +950,22 @@ public class Javac extends MatchingTask {
}

private String getAltCompilerName(final String anImplementation) {
if (JAVAC10_PLUS.equalsIgnoreCase(anImplementation)
|| JAVAC9.equalsIgnoreCase(anImplementation)
|| JAVAC19.equalsIgnoreCase(anImplementation)
|| JAVAC18.equalsIgnoreCase(anImplementation)
|| JAVAC17.equalsIgnoreCase(anImplementation)
|| JAVAC16.equalsIgnoreCase(anImplementation)
|| JAVAC15.equalsIgnoreCase(anImplementation)
|| JAVAC14.equalsIgnoreCase(anImplementation)
|| JAVAC13.equalsIgnoreCase(anImplementation)) {
return MODERN;
if (CompilerAdapterFactory.isModernJdkCompiler(anImplementation)) {
return CompilerAdapterFactory.COMPILER_MODERN;
}
if (JAVAC12.equalsIgnoreCase(anImplementation)
|| JAVAC11.equalsIgnoreCase(anImplementation)) {
return CLASSIC;
if (CompilerAdapterFactory.isClassicJdkCompiler(anImplementation)) {
return CompilerAdapterFactory.COMPILER_CLASSIC;
}
if (MODERN.equalsIgnoreCase(anImplementation)) {
if (CompilerAdapterFactory.COMPILER_MODERN.equalsIgnoreCase(anImplementation)) {
final String nextSelected = assumedJavaVersion();
if (JAVAC10_PLUS.equalsIgnoreCase(anImplementation)
|| JAVAC9.equalsIgnoreCase(nextSelected)
|| JAVAC18.equalsIgnoreCase(nextSelected)
|| JAVAC17.equalsIgnoreCase(nextSelected)
|| JAVAC16.equalsIgnoreCase(nextSelected)
|| JAVAC15.equalsIgnoreCase(nextSelected)
|| JAVAC14.equalsIgnoreCase(nextSelected)
|| JAVAC13.equalsIgnoreCase(nextSelected)) {
if (CompilerAdapterFactory.isModernJdkCompiler(nextSelected)) {
return nextSelected;
}
}
if (CLASSIC.equalsIgnoreCase(anImplementation)) {
if (CompilerAdapterFactory.COMPILER_CLASSIC.equalsIgnoreCase(anImplementation)) {
return assumedJavaVersion();
}
if (EXTJAVAC.equalsIgnoreCase(anImplementation)) {
if (CompilerAdapterFactory.isForkedJavac(anImplementation)) {
return assumedJavaVersion();
}
return null;
@@ -1256,18 +1225,7 @@ public class Javac extends MatchingTask {
* "javac1.6", "javac1.7", "javac1.8", "javac1.9", "javac9" or "javac10+".
*/
protected boolean isJdkCompiler(final String compilerImpl) {
return MODERN.equals(compilerImpl)
|| CLASSIC.equals(compilerImpl)
|| JAVAC10_PLUS.equals(compilerImpl)
|| JAVAC9.equals(compilerImpl)
|| JAVAC18.equals(compilerImpl)
|| JAVAC17.equals(compilerImpl)
|| JAVAC16.equals(compilerImpl)
|| JAVAC15.equals(compilerImpl)
|| JAVAC14.equals(compilerImpl)
|| JAVAC13.equals(compilerImpl)
|| JAVAC12.equals(compilerImpl)
|| JAVAC11.equals(compilerImpl);
return CompilerAdapterFactory.isJdkCompiler(compilerImpl);
}

/**
@@ -1304,7 +1262,7 @@ public class Javac extends MatchingTask {
String compilerImpl = getCompilerVersion();
if (fork) {
if (isJdkCompiler(compilerImpl)) {
compilerImpl = EXTJAVAC;
compilerImpl = CompilerAdapterFactory.COMPILER_EXTJAVAC;
} else {
log("Since compiler setting isn't classic or modern, "
+ "ignoring fork setting.", Project.MSG_WARN);


+ 151
- 24
src/main/org/apache/tools/ant/taskdefs/compilers/CompilerAdapterFactory.java View File

@@ -18,6 +18,9 @@

package org.apache.tools.ant.taskdefs.compilers;

import java.util.Arrays;
import java.util.List;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
@@ -33,6 +36,83 @@ import org.apache.tools.ant.util.JavaEnvUtils;
public final class CompilerAdapterFactory {
private static final String MODERN_COMPILER = "com.sun.tools.javac.Main";

public static final String COMPILER_JIKES = "jikes";
public static final String COMPILER_GCJ = "gcj";
public static final String COMPILER_SYMANTEC_ALIAS = "sj";
public static final String COMPILER_SYMANTEC = "symantec";
public static final String COMPILER_JVC_ALIAS = "microsoft";
public static final String COMPILER_JVC = "jvc";
public static final String COMPILER_KJC = "kjc";

public static final String COMPILER_JAVAC_1_1 = "javac1.1";
public static final String COMPILER_JAVAC_1_2 = "javac1.2";
public static final String COMPILER_JAVAC_1_3 = "javac1.3";
public static final String COMPILER_JAVAC_1_4 = "javac1.4";
public static final String COMPILER_JAVAC_1_5 = "javac1.5";
public static final String COMPILER_JAVAC_1_6 = "javac1.6";
public static final String COMPILER_JAVAC_1_7 = "javac1.7";
public static final String COMPILER_JAVAC_1_8 = "javac1.8";
public static final String COMPILER_JAVAC_9_ALIAS = "javac1.9";
public static final String COMPILER_JAVAC_9 = "javac9";
public static final String COMPILER_JAVAC_10_PLUS = "javac10+";

public static final String COMPILER_CLASSIC = "classic";
public static final String COMPILER_MODERN = "modern";
public static final String COMPILER_EXTJAVAC = "extJavac";

public static final String COMPILER_MODERN_CLASSNAME = Javac13.class.getName();
public static final String COMPILER_EXTJAVAC_CLASSNAME = JavacExternal.class.getName();

private static final List<String> JDK_COMPILERS = Arrays.asList(
COMPILER_JAVAC_1_1,
COMPILER_JAVAC_1_2,
COMPILER_JAVAC_1_3,
COMPILER_JAVAC_1_4,
COMPILER_JAVAC_1_5,
COMPILER_JAVAC_1_6,
COMPILER_JAVAC_1_7,
COMPILER_JAVAC_1_8,
COMPILER_JAVAC_9_ALIAS,
COMPILER_JAVAC_9,
COMPILER_JAVAC_10_PLUS,
COMPILER_CLASSIC,
COMPILER_MODERN,
COMPILER_EXTJAVAC,
COMPILER_MODERN_CLASSNAME,
COMPILER_EXTJAVAC_CLASSNAME
);

private static final List<String> FORKED_JDK_COMPILERS = Arrays.asList(
COMPILER_EXTJAVAC,
COMPILER_EXTJAVAC_CLASSNAME
);

private static final List<String> JDK_COMPILER_NICKNAMES = Arrays.asList(
COMPILER_CLASSIC,
COMPILER_MODERN,
COMPILER_EXTJAVAC,
COMPILER_MODERN_CLASSNAME,
COMPILER_EXTJAVAC_CLASSNAME
);

private static final List<String> CLASSIC_JDK_COMPILERS = Arrays.asList(
COMPILER_JAVAC_1_1,
COMPILER_JAVAC_1_2
);

private static final List<String> MODERN_JDK_COMPILERS = Arrays.asList(
COMPILER_JAVAC_1_3,
COMPILER_JAVAC_1_4,
COMPILER_JAVAC_1_5,
COMPILER_JAVAC_1_6,
COMPILER_JAVAC_1_7,
COMPILER_JAVAC_1_8,
COMPILER_JAVAC_9_ALIAS,
COMPILER_JAVAC_9,
COMPILER_JAVAC_10_PLUS,
COMPILER_MODERN_CLASSNAME
);

/** This is a singleton -- can't create instances!! */
private CompilerAdapterFactory() {
}
@@ -98,33 +178,22 @@ public final class CompilerAdapterFactory {
public static CompilerAdapter getCompiler(String compilerType, Task task,
Path classpath)
throws BuildException {
if (compilerType.equalsIgnoreCase("jikes")) {
if (compilerType.equalsIgnoreCase(COMPILER_JIKES)) {
return new Jikes();
}
if (compilerType.equalsIgnoreCase("extjavac")) {
if (isForkedJavac(compilerType)) {
return new JavacExternal();
}
if (compilerType.equalsIgnoreCase("classic")
|| compilerType.equalsIgnoreCase("javac1.1")
|| compilerType.equalsIgnoreCase("javac1.2")) {
if (compilerType.equalsIgnoreCase(COMPILER_CLASSIC)
|| isClassicJdkCompiler(compilerType)) {
task.log("This version of java does "
+ "not support the classic "
+ "compiler; upgrading to modern",
Project.MSG_WARN);
compilerType = "modern";
compilerType = COMPILER_MODERN;
}
//on java<=1.3 the modern falls back to classic if it is not found
//but on java>=1.4 we just bail out early
if (compilerType.equalsIgnoreCase("modern")
|| compilerType.equalsIgnoreCase("javac1.3")
|| compilerType.equalsIgnoreCase("javac1.4")
|| compilerType.equalsIgnoreCase("javac1.5")
|| compilerType.equalsIgnoreCase("javac1.6")
|| compilerType.equalsIgnoreCase("javac1.7")
|| compilerType.equalsIgnoreCase("javac1.8")
|| compilerType.equalsIgnoreCase("javac1.9")
|| compilerType.equalsIgnoreCase("javac9")
|| compilerType.equalsIgnoreCase("javac10+")) {
if (compilerType.equalsIgnoreCase(COMPILER_MODERN)
|| isModernJdkCompiler(compilerType)) {
// does the modern compiler exist?
if (doesModernCompilerExist()) {
return new Javac13();
@@ -142,18 +211,18 @@ public final class CompilerAdapterFactory {
}
}

if (compilerType.equalsIgnoreCase("jvc")
|| compilerType.equalsIgnoreCase("microsoft")) {
if (compilerType.equalsIgnoreCase(COMPILER_JVC)
|| compilerType.equalsIgnoreCase(COMPILER_JVC_ALIAS)) {
return new Jvc();
}
if (compilerType.equalsIgnoreCase("kjc")) {
if (compilerType.equalsIgnoreCase(COMPILER_KJC)) {
return new Kjc();
}
if (compilerType.equalsIgnoreCase("gcj")) {
if (compilerType.equalsIgnoreCase(COMPILER_GCJ)) {
return new Gcj();
}
if (compilerType.equalsIgnoreCase("sj")
|| compilerType.equalsIgnoreCase("symantec")) {
if (compilerType.equalsIgnoreCase(COMPILER_SYMANTEC_ALIAS)
|| compilerType.equalsIgnoreCase(COMPILER_SYMANTEC)) {
return new Sj();
}
return resolveClassName(compilerType,
@@ -201,4 +270,62 @@ public final class CompilerAdapterFactory {
CompilerAdapter.class);
}

/**
* Is the compiler implementation a forked jdk compiler?
*
* @param compilerImpl the name of the compiler implementation
* @since 1.9.17
*/
public static boolean isForkedJavac(final String compilerName) {
return containsIgnoreCase(FORKED_JDK_COMPILERS, compilerName);
}

/**
* Is the compiler implementation a jdk compiler?
*
* @param compilerImpl the name of the compiler implementation
* @since 1.9.17
*/
public static boolean isJdkCompiler(final String compilerName) {
return containsIgnoreCase(JDK_COMPILERS, compilerName);
}

/**
* Is the compiler implementation a jdk compiler without specified version?
*
* @param compilerImpl the name of the compiler implementation
* @since 1.9.17
*/
public static boolean isJdkCompilerNickname(final String compilerName) {
return containsIgnoreCase(JDK_COMPILER_NICKNAMES, compilerName);
}

/**
* Does the compiler correspond to "classic"?
*
* @param compilerImpl the name of the compiler implementation
* @since 1.9.17
*/
public static boolean isClassicJdkCompiler(final String compilerName) {
return containsIgnoreCase(CLASSIC_JDK_COMPILERS, compilerName);
}

/**
* Does the compiler correspond to "modern"?
*
* @param compilerImpl the name of the compiler implementation
* @since 1.9.17
*/
public static boolean isModernJdkCompiler(final String compilerName) {
return containsIgnoreCase(MODERN_JDK_COMPILERS, compilerName);
}

private static boolean containsIgnoreCase(final List<String> compilers, final String compilerName) {
for (String compiler : compilers) {
if (compiler.equalsIgnoreCase(compilerName)) {
return true;
}
}
return false;
}
}

+ 19
- 20
src/main/org/apache/tools/ant/taskdefs/compilers/DefaultCompilerAdapter.java View File

@@ -632,7 +632,8 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.5
*/
protected boolean assumeJava11() {
return "javac1.1".equals(attributes.getCompilerVersion());
return CompilerAdapterFactory.COMPILER_JAVAC_1_1
.equalsIgnoreCase(attributes.getCompilerVersion());
}

/**
@@ -641,7 +642,8 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.5
*/
protected boolean assumeJava12() {
return "javac1.2".equals(attributes.getCompilerVersion());
return CompilerAdapterFactory.COMPILER_JAVAC_1_2
.equalsIgnoreCase(attributes.getCompilerVersion());
}

/**
@@ -650,7 +652,8 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.5
*/
protected boolean assumeJava13() {
return "javac1.3".equals(attributes.getCompilerVersion());
return CompilerAdapterFactory.COMPILER_JAVAC_1_3
.equalsIgnoreCase(attributes.getCompilerVersion());
}

/**
@@ -659,7 +662,7 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.6.3
*/
protected boolean assumeJava14() {
return assumeJavaXY("javac1.4", JavaEnvUtils.JAVA_1_4);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_1_4, JavaEnvUtils.JAVA_1_4);
}

/**
@@ -668,7 +671,7 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.6.3
*/
protected boolean assumeJava15() {
return assumeJavaXY("javac1.5", JavaEnvUtils.JAVA_1_5);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_1_5, JavaEnvUtils.JAVA_1_5);
}

/**
@@ -677,7 +680,7 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.7
*/
protected boolean assumeJava16() {
return assumeJavaXY("javac1.6", JavaEnvUtils.JAVA_1_6);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_1_6, JavaEnvUtils.JAVA_1_6);
}

/**
@@ -686,7 +689,7 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.8.2
*/
protected boolean assumeJava17() {
return assumeJavaXY("javac1.7", JavaEnvUtils.JAVA_1_7);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_1_7, JavaEnvUtils.JAVA_1_7);
}

/**
@@ -695,7 +698,7 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.8.3
*/
protected boolean assumeJava18() {
return assumeJavaXY("javac1.8", JavaEnvUtils.JAVA_1_8);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_1_8, JavaEnvUtils.JAVA_1_8);
}

/**
@@ -705,8 +708,8 @@ public abstract class DefaultCompilerAdapter
* @deprecated use #assumeJava9 instead
*/
protected boolean assumeJava19() {
return assumeJavaXY("javac1.9", JavaEnvUtils.JAVA_9)
|| assumeJavaXY("javac9", JavaEnvUtils.JAVA_9);
return assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_9, JavaEnvUtils.JAVA_9)
|| assumeJavaXY(CompilerAdapterFactory.COMPILER_JAVAC_9_ALIAS, JavaEnvUtils.JAVA_9);
}

/**
@@ -724,13 +727,11 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.9.10
*/
protected boolean assumeJava9Plus() {
return "javac1.9".equals(attributes.getCompilerVersion())
|| "javac9".equals(attributes.getCompilerVersion())
|| "javac10+".equals(attributes.getCompilerVersion())
return CompilerAdapterFactory.COMPILER_JAVAC_9.equalsIgnoreCase(attributes.getCompilerVersion())
|| CompilerAdapterFactory.COMPILER_JAVAC_9_ALIAS.equalsIgnoreCase(attributes.getCompilerVersion())
|| CompilerAdapterFactory.COMPILER_JAVAC_10_PLUS.equalsIgnoreCase(attributes.getCompilerVersion())
|| (JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.JAVA_9)
&& ("classic".equals(attributes.getCompilerVersion())
|| "modern".equals(attributes.getCompilerVersion())
|| "extJavac".equals(attributes.getCompilerVersion())));
&& CompilerAdapterFactory.isJdkCompilerNickname(attributes.getCompilerVersion()));
}

/**
@@ -738,11 +739,9 @@ public abstract class DefaultCompilerAdapter
* @since Ant 1.8.3
*/
private boolean assumeJavaXY(final String javacXY, final String javaEnvVersionXY) {
return javacXY.equals(attributes.getCompilerVersion())
return javacXY.equalsIgnoreCase(attributes.getCompilerVersion())
|| (JavaEnvUtils.isJavaVersion(javaEnvVersionXY)
&& ("classic".equals(attributes.getCompilerVersion())
|| "modern".equals(attributes.getCompilerVersion())
|| "extJavac".equals(attributes.getCompilerVersion())));
&& CompilerAdapterFactory.isJdkCompilerNickname(attributes.getCompilerVersion()));
}

/**


+ 10
- 2
src/tests/junit/org/apache/tools/ant/taskdefs/JavacTest.java View File

@@ -19,21 +19,24 @@
package org.apache.tools.ant.taskdefs;

import java.io.File;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.compilers.CompilerAdapter;
import org.apache.tools.ant.taskdefs.compilers.CompilerAdapterFactory;
import org.apache.tools.ant.taskdefs.compilers.Javac13;
import org.apache.tools.ant.taskdefs.compilers.JavacExternal;
import org.apache.tools.ant.types.Path;

import org.junit.Before;
import org.junit.Test;

import static org.apache.tools.ant.AntAssert.assertContains;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.Path;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

@@ -74,6 +77,11 @@ public class JavacTest {
assertNotNull("fork via property", javac.getJavacExecutable());
assertContains("name should contain \"javac\"", "javac", javac.getJavacExecutable());

project.setProperty("build.compiler", "org.apache.tools.ant.taskdefs.compilers.JavacExternal");
javac.setFork(false);
assertNotNull("fork via property", javac.getJavacExecutable());
assertThat("name should contain \"javac\"", javac.getJavacExecutable(), containsString("javac"));

project.setProperty("build.compiler", "whatever");
assertNull("no fork and not extJavac means no executable",
javac.getJavacExecutable());


+ 49
- 4
src/tests/junit/org/apache/tools/ant/taskdefs/compilers/DefaultCompilerAdapterTest.java View File

@@ -25,17 +25,21 @@ import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Javac;
import org.apache.tools.ant.types.Commandline;
import org.junit.Test;

import static org.apache.tools.ant.AntAssert.assertContains;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.util.FileUtils;
import org.apache.tools.ant.util.JavaEnvUtils;
import org.junit.Assert;
import org.junit.Test;

import static org.apache.tools.ant.AntAssert.assertContains;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class DefaultCompilerAdapterTest {

@@ -449,6 +453,47 @@ public class DefaultCompilerAdapterTest {
assertEquals("6", args[4]);
}

/**
* @see "https://bz.apache.org/bugzilla/show_bug.cgi?id=65539"
*/
@Test
public void assumeJavaXPlusWorksWithBuildCompilerSetToExplicitAdapterName() {
LogCapturingJavac javac = new LogCapturingJavac();
Project p = new Project();
p.setProperty("build.compiler", "org.apache.tools.ant.taskdefs.compilers.JavacExternal");
javac.setProject(p);
javac.setFork(true);
javac.setSourcepath(new Path(p));
SourceTargetHelperNoOverride ca = new SourceTargetHelperNoOverride();
ca.setJavac(javac);
if (JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.JAVA_9)) {
assertTrue(ca.assumeJava9Plus());
assertTrue(ca.assumeJava9());
assertTrue(ca.assumeJava19());
assertFalse(ca.assumeJava18());
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_8)) {
assertFalse(ca.assumeJava9Plus());
assertFalse(ca.assumeJava9());
assertTrue(ca.assumeJava18());
assertFalse(ca.assumeJava17());
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_7)) {
assertFalse(ca.assumeJava9Plus());
assertFalse(ca.assumeJava18());
assertTrue(ca.assumeJava17());
assertFalse(ca.assumeJava16());
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6)) {
assertFalse(ca.assumeJava9Plus());
assertFalse(ca.assumeJava17());
assertTrue(ca.assumeJava16());
assertFalse(ca.assumeJava15());
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5)) {
assertFalse(ca.assumeJava9Plus());
assertFalse(ca.assumeJava16());
assertTrue(ca.assumeJava15());
assertFalse(ca.assumeJava14());
}
}

private void commonSourceDowngrades(String javaVersion) {
testSource("1.3", javaVersion,
"If you specify -target 1.1 you now must also specify"


Write Preview
Loading…
Cancel
Save