| /* |
| * 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(); |
| } |