213 lines
8.8 KiB
Java
213 lines
8.8 KiB
Java
/*
|
|
* Copyright (c) 2016, 2017, 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
|
|
* @bug 8171005 8175560
|
|
* @summary Verify behavior of JavaFileManager methods w.r.t. module/package oriented locations
|
|
* @library /tools/lib
|
|
* @modules java.compiler
|
|
* @build toolbox.TestRunner ModuleAndPackageLocations
|
|
* @run main ModuleAndPackageLocations
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.StreamSupport;
|
|
|
|
import javax.tools.JavaCompiler;
|
|
import javax.tools.JavaFileManager;
|
|
import javax.tools.JavaFileManager.Location;
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.JavaFileObject.Kind;
|
|
import javax.tools.StandardJavaFileManager;
|
|
import javax.tools.StandardLocation;
|
|
import javax.tools.ToolProvider;
|
|
|
|
import toolbox.TestRunner;
|
|
import toolbox.TestRunner.Test;
|
|
|
|
public class ModuleAndPackageLocations extends TestRunner {
|
|
|
|
public static void main(String... args) throws Exception {
|
|
new ModuleAndPackageLocations().runTests(m -> new Object[] { Paths.get(m.getName()) });
|
|
}
|
|
|
|
public ModuleAndPackageLocations() {
|
|
super(System.err);
|
|
}
|
|
|
|
@Test
|
|
public void testListLocations(Path outerBase) throws Exception {
|
|
doRunTest(outerBase, (base, fm) -> {
|
|
assertLocations(fm.listLocationsForModules(StandardLocation.MODULE_SOURCE_PATH),
|
|
toSet("MODULE_SOURCE_PATH[a]:false:false",
|
|
"MODULE_SOURCE_PATH[b]:false:false",
|
|
"MODULE_SOURCE_PATH[c]:false:false"));
|
|
assertLocations(fm.listLocationsForModules(StandardLocation.MODULE_PATH),
|
|
toSet("MODULE_PATH[0.X,a]:false:false",
|
|
"MODULE_PATH[0.X,b]:false:false"),
|
|
toSet("MODULE_PATH[1.X,c]:false:false",
|
|
"MODULE_PATH[1.X,b]:false:false"));
|
|
assertLocations(fm.listLocationsForModules(StandardLocation.SOURCE_OUTPUT),
|
|
toSet("SOURCE_OUTPUT[a]:false:true",
|
|
"SOURCE_OUTPUT[b]:false:true"));
|
|
|
|
fm.getLocationForModule(StandardLocation.SOURCE_OUTPUT, "c");
|
|
|
|
assertLocations(fm.listLocationsForModules(StandardLocation.SOURCE_OUTPUT),
|
|
toSet("SOURCE_OUTPUT[a]:false:true",
|
|
"SOURCE_OUTPUT[b]:false:true",
|
|
"SOURCE_OUTPUT[c]:false:true"));
|
|
});
|
|
}
|
|
|
|
@Test
|
|
public void testGetModuleForPath(Path outerBase) throws Exception {
|
|
doRunTest(outerBase, (base, fm) -> {
|
|
Location cOutput = fm.getLocationForModule(StandardLocation.SOURCE_OUTPUT, "c");
|
|
JavaFileObject testFO = fm.getJavaFileForOutput(cOutput, "test.Test", Kind.CLASS, null);
|
|
testFO.openOutputStream().close();
|
|
Location cOutput2 = fm.getLocationForModule(StandardLocation.SOURCE_OUTPUT, testFO);
|
|
|
|
if (cOutput != cOutput2) {
|
|
throw new AssertionError("Unexpected location: " + cOutput2 + ", expected: " +cOutput);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Test
|
|
public void testRejects(Path outerBase) throws Exception {
|
|
doRunTest(outerBase, (base, fm) -> {
|
|
assertRefused(() -> fm.getClassLoader(StandardLocation.MODULE_SOURCE_PATH));
|
|
assertRefused(() -> fm.getFileForInput(StandardLocation.MODULE_SOURCE_PATH, "", ""));
|
|
assertRefused(() -> fm.getFileForOutput(StandardLocation.MODULE_SOURCE_PATH, "", "", null));
|
|
assertRefused(() -> fm.getJavaFileForInput(StandardLocation.MODULE_SOURCE_PATH, "", Kind.SOURCE));
|
|
assertRefused(() -> fm.getJavaFileForOutput(StandardLocation.MODULE_SOURCE_PATH, "", Kind.SOURCE, null));
|
|
assertRefused(() -> fm.getLocationForModule(StandardLocation.SOURCE_PATH, "test"));
|
|
JavaFileObject out = fm.getJavaFileForInput(StandardLocation.CLASS_OUTPUT, "test.Test", Kind.CLASS);
|
|
assertRefused(() -> fm.inferBinaryName(StandardLocation.MODULE_PATH, out));
|
|
assertRefused(() -> fm.inferModuleName(StandardLocation.MODULE_SOURCE_PATH));
|
|
assertRefused(() -> fm.list(StandardLocation.MODULE_SOURCE_PATH, "test", EnumSet.allOf(Kind.class), false));
|
|
assertRefused(() -> fm.listLocationsForModules(StandardLocation.SOURCE_PATH));
|
|
});
|
|
}
|
|
|
|
void doRunTest(Path base, TestExec test) throws Exception {
|
|
try (StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null)) {
|
|
Path msp = base.resolve("msp");
|
|
Path msp1 = msp.resolve("1");
|
|
Path msp2 = msp.resolve("2");
|
|
|
|
touch(msp1.resolve("a/module-info.java"));
|
|
Files.createDirectories(msp1.resolve("b"));
|
|
touch(msp2.resolve("b/module-info.java"));
|
|
touch(msp2.resolve("c/module-info.java"));
|
|
|
|
Path mp = base.resolve("mp");
|
|
Path mp1 = mp.resolve("1");
|
|
Path mp2 = mp.resolve("2");
|
|
|
|
touch(mp1.resolve("a/module-info.class"),
|
|
mp1.resolve("b/module-info.class"),
|
|
mp2.resolve("b/module-info.class"),
|
|
mp2.resolve("c/module-info.class"));
|
|
|
|
Path so = base.resolve("so");
|
|
|
|
Files.createDirectories(so.resolve("a"));
|
|
Files.createDirectories(so.resolve("b"));
|
|
|
|
List<String> mspOpt = Arrays.asList(msp1.toAbsolutePath().toString() +
|
|
File.pathSeparatorChar +
|
|
msp2.toAbsolutePath().toString());
|
|
|
|
List<String> mpOpt = Arrays.asList(mp1.toAbsolutePath().toString() +
|
|
File.pathSeparatorChar +
|
|
mp2.toAbsolutePath().toString());
|
|
|
|
fm.handleOption("--module-source-path", mspOpt.iterator());
|
|
fm.handleOption("--module-path", mpOpt.iterator());
|
|
fm.handleOption("-s", Arrays.asList(so.toString()).iterator());
|
|
|
|
test.run(base, fm);
|
|
}
|
|
}
|
|
|
|
private Set<String> toSet(String... values) {
|
|
return new HashSet<>(Arrays.asList(values));
|
|
}
|
|
|
|
private void touch(Path... paths) throws IOException {
|
|
for (Path p : paths) {
|
|
Files.createDirectories(p.getParent());
|
|
Files.newOutputStream(p).close();
|
|
}
|
|
}
|
|
|
|
@SafeVarargs
|
|
private void assertLocations(Iterable<Set<Location>> locations, Set<String>... expected) {
|
|
List<Set<String>> actual =
|
|
StreamSupport.stream(locations.spliterator(), true)
|
|
.map(locs -> locs.stream()
|
|
.map(l -> toString(l))
|
|
.collect(Collectors.toSet()))
|
|
.collect(Collectors.toList());
|
|
|
|
if (!Objects.equals(actual, Arrays.asList(expected))) {
|
|
throw new AssertionError("Unexpected output: " + actual);
|
|
}
|
|
}
|
|
|
|
private void assertRefused(Callable r) throws Exception {
|
|
try {
|
|
r.call();
|
|
throw new AssertionError("Expected exception did not occur");
|
|
} catch (IllegalArgumentException ex) {
|
|
//ok
|
|
}
|
|
}
|
|
|
|
private static String toString(Location l) {
|
|
return l.getName().replaceAll("\\[([0-9])\\.[0-9]:", "[$1.X,") + ":" +
|
|
l.isModuleOrientedLocation() + ":" + l.isOutputLocation();
|
|
}
|
|
|
|
static interface TestExec {
|
|
public void run(Path base, JavaFileManager fm) throws Exception;
|
|
}
|
|
|
|
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
|
|
}
|