/*
* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @summary Tests which path is used to represent an implicit type given
* various xprefer arguments and multiple .class / .java files involved.
* @bug 8028196
* @modules jdk.compiler
*/
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.regex.Pattern;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class XPreferTest {
enum Dir {
SOURCE_PATH("src"),
CLASS_PATH("cp"),
BOOT_PATH("boot");
File file;
Dir(String dir) {
this.file = new File(dir);
}
}
enum ImplicitOption {
XPREFER_SOURCE("-Xprefer:source"),
XPREFER_NEWER("-Xprefer:newer"),
XXUSERPATHSFIRST("-XXuserPathsFirst");
final String optionString;
private ImplicitOption(String optionString) {
this.optionString = optionString;
}
}
final static JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
final static StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
final static File OUTPUT_DIR = new File("out");
public static void main(String... args) throws Exception {
try {
// Initialize test-directories
OUTPUT_DIR.mkdir();
for (Dir dir : Dir.values())
dir.file.mkdir();
int testCaseCounter = 0;
for (List<Dir> dirSubset : SubseqIter.subseqsOf(Dir.values())) {
if (dirSubset.isEmpty())
continue;
for (ImplicitOption policy : ImplicitOption.values()) {
for (List<Dir> dirOrder : PermutationIterator.permutationsOf(dirSubset)) {
new TestCase(dirOrder, policy, testCaseCounter++).run();
}
}
}
} finally {
fm.close();
}
}
static class TestCase {
String classId;
List<Dir> dirs;
ImplicitOption option;
public TestCase(List<Dir> dirs, ImplicitOption option, int testCaseNum) {
this.dirs = dirs;
this.option = option;
this.classId = "XPreferTestImplicit" + testCaseNum;
}
void run() throws Exception {
System.out.println("Test:");
System.out.println(" Class id: " + classId);
System.out.println(" Dirs: " + dirs);
System.out.println(" Option: " + option);
createTestFiles();
String compileOutput = compile();
Dir actual = getChosenOrigin(compileOutput);
Dir expected = getExpectedOrigin();
System.out.println(" Expected: " + expected);
System.out.println(" Actual: " + actual);
if (actual != expected) {
throw new RuntimeException(String.format(
"Expected javac to choose %s but %s was chosen",
expected == null ? "<none>" : expected.name(),
actual == null ? "<none>" : actual.name()));
}
}
Dir getExpectedOrigin() {
Dir newest = dirs.get(0);
switch (option) {
case XPREFER_NEWER:
Dir cls = dirs.contains(Dir.BOOT_PATH) ? Dir.BOOT_PATH
: dirs.contains(Dir.CLASS_PATH) ? Dir.CLASS_PATH
: null;
Dir src = dirs.contains(Dir.SOURCE_PATH) ? Dir.SOURCE_PATH
: null;
for (Dir dir : dirs)
if (dir == cls || dir == src)
return dir;
return null;
case XPREFER_SOURCE:
return dirs.contains(Dir.SOURCE_PATH) ? Dir.SOURCE_PATH
: dirs.contains(Dir.BOOT_PATH) ? Dir.BOOT_PATH
: dirs.contains(Dir.CLASS_PATH) ? Dir.CLASS_PATH
: null;
case XXUSERPATHSFIRST:
for (Dir dir : dirs)
if (dir == Dir.SOURCE_PATH || dir == Dir.CLASS_PATH)
return dir;
// Neither SOURCE_PATH nor CLASS_PATH among dirs. Safty check:
if (newest != Dir.BOOT_PATH)
throw new AssertionError("Expected to find BOOT_PATH");
return Dir.BOOT_PATH;
default:
throw new RuntimeException("Unhandled policy case.");
}
}
Dir getChosenOrigin(String compilerOutput) {
Scanner s = new Scanner(compilerOutput);
while (s.hasNextLine()) {
String line = s.nextLine();
if (line.matches("\\[loading .*\\]")) {
for (Dir dir : Dir.values()) {
// On Windows all paths are printed with '/' except
// paths inside zip-files, which are printed with '\'.
// For this reason we accept both '/' and '\' below.
String regex = dir.file.getName() + "[\\\\/]" + classId;
if (Pattern.compile(regex).matcher(line).find())
return dir;
}
}
}
return null;
}
String compile() throws IOException {
// Create a class that references classId
File explicit = new File("ExplicitClass.java");
FileWriter filewriter = new FileWriter(explicit);
filewriter.append("class ExplicitClass { " + classId + " implicit; }");
filewriter.close();
StringWriter sw = new StringWriter();
com.sun.tools.javac.Main.compile(new String[] {
"-verbose",
option.optionString,
"-source", "8", "-target", "8",
"-sourcepath", Dir.SOURCE_PATH.file.getPath(),
"-classpath", Dir.CLASS_PATH.file.getPath(),
"-Xbootclasspath/p:" + Dir.BOOT_PATH.file.getPath(),
"-d", XPreferTest.OUTPUT_DIR.getPath(),
explicit.getPath()
}, new PrintWriter(sw));
return sw.toString();
}
void createTestFiles() throws IOException {
long t = 1390927988755L; // Tue Jan 28 17:53:08 CET 2014
for (Dir dir : dirs) {
createFile(dir).setLastModified(t);
t -= 10000;
}
}
File createFile(Dir dir) throws IOException {
File src = new File(dir.file, classId + ".java");
try (FileWriter w = new FileWriter(src)) {
w.append("public class " + classId + " {}");
}
// If we're after the ".java" representation, we're done...
if(dir == Dir.SOURCE_PATH)
return src;
// ...otherwise compile into a ".class".
CompilationTask task = comp.getTask(null, fm, null, null, null,
fm.getJavaFileObjects(src));
File dest = new File(dir.file, classId + ".class");
if(!task.call() || !dest.exists())
throw new RuntimeException("Compilation failure.");
src.delete();
return dest;
}
}
}
// Iterator for iteration over all subsequences of a given list.
class SubseqIter<T> implements Iterator<List<T>> {
List<T> elements;
boolean[] states;
public SubseqIter(Collection<T> c) {
states = new boolean[c.size()];
elements = new ArrayList<T>(c);
}
public static <T> Iterable<List<T>> subseqsOf(final T[] t) {
return new Iterable<List<T>>() {
@Override
public Iterator<List<T>> iterator() {
return new SubseqIter<T>(Arrays.asList(t));
}
};
}
// Roll values in 'states' from index i and forward.
// Return true if we wrapped back to zero.
private boolean roll(int i) {
if (i == states.length)
return true;
if (!roll(i + 1))
return false;
states[i] = !states[i];
return !states[i];
}
@Override
public List<T> next() {
if (!hasNext())
throw new NoSuchElementException();
// Include element i if states[i] is true
List<T> next = new ArrayList<T>();
for (int i = 0; i < states.length; i++)
if (states[i])
next.add(elements.get(i));
if (roll(0))
states = null; // hasNext() == false from now on.
return next;
}
@Override
public boolean hasNext() {
return states != null;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
class PermutationIterator<T> implements Iterator<List<T>> {
DirInt head;
boolean hasNext = true;
public PermutationIterator(List<T> toPermute) {
ListIterator<T> iter = toPermute.listIterator();
if (iter.hasNext())
head = new DirInt(iter.nextIndex(), iter.next());
DirInt prev = head;
while (iter.hasNext()) {
DirInt di = new DirInt(iter.nextIndex(), iter.next());
di.left = prev;
prev.right = di;
prev = di;
}
}
public static <T> Iterable<List<T>> permutationsOf(final List<T> list) {
return new Iterable<List<T>>() {
public Iterator<List<T>> iterator() {
return new PermutationIterator<>(list);
}
};
}
@Override
public boolean hasNext() {
return hasNext;
}
@Override
public List<T> next() {
// Prep return value based on current state
List<T> result = new ArrayList<>();
for (DirInt di = head; di != null; di = di.right)
result.add(di.object);
// Step state forward
DirInt maxMob = null;
for (DirInt di = head; di != null; di = di.right)
if (di.isMobile() && (maxMob == null || di.val > maxMob.val))
maxMob = di;
if (maxMob == null) {
hasNext = false;
} else {
maxMob.swapWithAdjacent();
for (DirInt di = head; di != null; di = di.right)
if (di.val > maxMob.val)
di.facingLeft = !di.facingLeft;
}
return result;
}
private final class DirInt {
int val;
T object;
DirInt left, right;
boolean facingLeft = true;
public DirInt(int val, T object) {
this.val = val;
this.object = object;
}
boolean isMobile() {
DirInt adjacent = facingLeft ? left : right;
return adjacent != null && val > adjacent.val;
}
public void swapWithAdjacent() {
DirInt l = facingLeft ? left : this;
DirInt r = facingLeft ? this : right;
if (head == l) head = r;
if (l.left != null) l.left.right = r;
if (r.right != null) r.right.left = l;
l.right = r.right;
r.left = l.left;
r.right = l;
l.left = r;
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}