342 lines
11 KiB
Java
342 lines
11 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
|
|
* @summary Test --no-man-pages and --no-header-files
|
|
* @library /test/lib
|
|
* @modules jdk.compiler
|
|
* jdk.jlink
|
|
* @build jdk.test.lib.compiler.CompilerUtils
|
|
* @run testng ExcludeJmodSectionPluginTest
|
|
*/
|
|
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.nio.file.FileVisitResult;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.nio.file.SimpleFileVisitor;
|
|
import java.nio.file.attribute.BasicFileAttributes;
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.spi.ToolProvider;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
import jdk.test.lib.compiler.CompilerUtils;
|
|
|
|
import org.testng.annotations.BeforeTest;
|
|
import org.testng.annotations.DataProvider;
|
|
import org.testng.annotations.Test;
|
|
|
|
import static org.testng.Assert.*;
|
|
|
|
public class ExcludeJmodSectionPluginTest {
|
|
static final ToolProvider JMOD_TOOL = ToolProvider.findFirst("jmod")
|
|
.orElseThrow(() ->
|
|
new RuntimeException("jmod tool not found")
|
|
);
|
|
|
|
static final ToolProvider JLINK_TOOL = ToolProvider.findFirst("jlink")
|
|
.orElseThrow(() ->
|
|
new RuntimeException("jlink tool not found")
|
|
);
|
|
|
|
static final Path MODULE_PATH = Paths.get(System.getProperty("java.home"), "jmods");
|
|
static final Path SRC_DIR = Paths.get("src");
|
|
static final Path MODS_DIR = Paths.get("mods");
|
|
static final Path JMODS_DIR = Paths.get("jmods");
|
|
static final Path MAN_DIR = Paths.get("man");
|
|
static final Path INCLUDE_DIR = Paths.get("include");
|
|
static final Path IMAGES_DIR = Paths.get("images");
|
|
|
|
@BeforeTest
|
|
private void setup() throws Exception {
|
|
// build jmod files
|
|
JmodFileBuilder m1 = new JmodFileBuilder("m1");
|
|
m1.headerFile("m1a.h");
|
|
m1.headerFile("m1b.h");
|
|
m1.build();
|
|
|
|
JmodFileBuilder m2 = new JmodFileBuilder("m2");
|
|
m2.headerFile("m2.h");
|
|
m2.manPage("tool2.1");
|
|
m2.build();
|
|
|
|
JmodFileBuilder m3 = new JmodFileBuilder("m3");
|
|
m3.manPage("tool3.1");
|
|
m3.build();
|
|
}
|
|
|
|
private String imageDir(String dir) {
|
|
return IMAGES_DIR.resolve(dir).toString();
|
|
}
|
|
|
|
|
|
@DataProvider(name = "jlinkoptions")
|
|
public Object[][] jlinkoptions() {
|
|
// options and expected header files & man pages
|
|
return new Object[][] {
|
|
{ new String [] {
|
|
"test1",
|
|
"--exclude-files=/java.base/include/**,/java.base/man/**",
|
|
},
|
|
List.of("include/m1a.h",
|
|
"include/m1b.h",
|
|
"include/m2.h",
|
|
"man/tool2.1",
|
|
"man/tool3.1")
|
|
},
|
|
|
|
{ new String [] {
|
|
"test2",
|
|
"--no-man-pages",
|
|
"--no-header-files",
|
|
},
|
|
List.of()
|
|
},
|
|
|
|
{ new String[] {
|
|
"test3",
|
|
"--no-header-files",
|
|
"--exclude-files=/java.base/man/**"
|
|
},
|
|
List.of("man/tool2.1",
|
|
"man/tool3.1") },
|
|
|
|
{ new String [] {
|
|
"test4",
|
|
"--no-man-pages",
|
|
"--exclude-files=/java.base/include/**,/m2/include/**",
|
|
},
|
|
List.of("include/m1a.h",
|
|
"include/m1b.h")
|
|
},
|
|
|
|
{ new String [] {
|
|
"test5",
|
|
"--no-header-files",
|
|
"--exclude-files=/java.base/man/**,/m2/man/**"
|
|
},
|
|
List.of("man/tool3.1")
|
|
},
|
|
};
|
|
}
|
|
|
|
@Test(dataProvider = "jlinkoptions")
|
|
public void test(String[] opts, List<String> expectedFiles) throws Exception {
|
|
if (Files.notExists(MODULE_PATH)) {
|
|
// exploded image
|
|
return;
|
|
}
|
|
|
|
String dir = opts[0];
|
|
List<String> options = new ArrayList<>();
|
|
for (int i = 1; i < opts.length; i++) {
|
|
options.add(opts[i]);
|
|
}
|
|
|
|
String mpath = MODULE_PATH.toString() + File.pathSeparator +
|
|
JMODS_DIR.toString();
|
|
Stream.of("--module-path", mpath,
|
|
"--add-modules", "m1,m2,m3",
|
|
"--output", imageDir(dir))
|
|
.forEach(options::add);
|
|
|
|
Path image = createImage(dir, options, expectedFiles);
|
|
|
|
// check if any unexpected header file or man page
|
|
Set<Path> extraFiles = Files.walk(image, Integer.MAX_VALUE)
|
|
.filter(p -> Files.isRegularFile(p))
|
|
.filter(p -> p.getParent().endsWith("include") ||
|
|
p.getParent().endsWith("man"))
|
|
.filter(p -> {
|
|
String fn = String.format("%s/%s",
|
|
p.getParent().getFileName().toString(),
|
|
p.getFileName().toString());
|
|
return !expectedFiles.contains(fn);
|
|
})
|
|
.collect(Collectors.toSet());
|
|
|
|
if (extraFiles.size() > 0) {
|
|
System.out.println("Unexpected files: " + extraFiles.toString());
|
|
assertTrue(extraFiles.isEmpty());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test java.base's include header files
|
|
*/
|
|
@Test
|
|
public void testJavaBase() {
|
|
if (Files.notExists(MODULE_PATH)) {
|
|
// exploded image
|
|
return;
|
|
}
|
|
List<String> options = List.of("--module-path",
|
|
MODULE_PATH.toString(),
|
|
"--add-modules", "java.base",
|
|
"--output", imageDir("base"));
|
|
createImage("base", options,
|
|
List.of("include/jni.h", "include/jvmti.h"));
|
|
|
|
}
|
|
|
|
private Path createImage(String outputDir, List<String> options,
|
|
List<String> expectedFiles) {
|
|
System.out.println("jlink " + options.toString());
|
|
int rc = JLINK_TOOL.run(System.out, System.out,
|
|
options.toArray(new String[0]));
|
|
assertTrue(rc == 0);
|
|
|
|
Path d = IMAGES_DIR.resolve(outputDir);
|
|
for (String fn : expectedFiles) {
|
|
Path path = d.resolve(fn);
|
|
if (Files.notExists(path)) {
|
|
throw new RuntimeException(path + " not found");
|
|
}
|
|
}
|
|
return d;
|
|
}
|
|
|
|
private void deleteDirectory(Path dir) throws IOException {
|
|
Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
|
|
@Override
|
|
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
|
|
throws IOException
|
|
{
|
|
Files.delete(file);
|
|
return FileVisitResult.CONTINUE;
|
|
}
|
|
|
|
@Override
|
|
public FileVisitResult postVisitDirectory(Path dir, IOException exc)
|
|
throws IOException
|
|
{
|
|
Files.delete(dir);
|
|
return FileVisitResult.CONTINUE;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Builder to create JMOD file
|
|
*/
|
|
class JmodFileBuilder {
|
|
|
|
final String name;
|
|
final Set<String> manPages = new HashSet<>();
|
|
final Set<String> headerFiles = new HashSet<>();
|
|
|
|
JmodFileBuilder(String name) throws IOException {
|
|
this.name = name;
|
|
|
|
Path msrc = SRC_DIR.resolve(name);
|
|
if (Files.exists(msrc)) {
|
|
deleteDirectory(msrc);
|
|
}
|
|
}
|
|
|
|
JmodFileBuilder manPage(String filename) {
|
|
manPages.add(filename);
|
|
return this;
|
|
}
|
|
|
|
JmodFileBuilder headerFile(String filename) {
|
|
headerFiles.add(filename);
|
|
return this;
|
|
}
|
|
|
|
Path build() throws IOException {
|
|
compileModule();
|
|
// create man pages
|
|
Path mdir = MAN_DIR.resolve(name);
|
|
for (String filename : manPages) {
|
|
Files.createDirectories(mdir);
|
|
Files.createFile(mdir.resolve(filename));
|
|
}
|
|
// create header files
|
|
mdir = INCLUDE_DIR.resolve(name);
|
|
for (String filename : headerFiles) {
|
|
Files.createDirectories(mdir);
|
|
Files.createFile(mdir.resolve(filename));
|
|
}
|
|
return createJmodFile();
|
|
}
|
|
|
|
void compileModule() throws IOException {
|
|
Path msrc = SRC_DIR.resolve(name);
|
|
Files.createDirectories(msrc);
|
|
Path minfo = msrc.resolve("module-info.java");
|
|
try (BufferedWriter bw = Files.newBufferedWriter(minfo);
|
|
PrintWriter writer = new PrintWriter(bw)) {
|
|
writer.format("module %s { }%n", name);
|
|
}
|
|
|
|
assertTrue(CompilerUtils.compile(msrc, MODS_DIR,
|
|
"--module-source-path",
|
|
SRC_DIR.toString()));
|
|
}
|
|
|
|
Path createJmodFile() throws IOException {
|
|
Path mclasses = MODS_DIR.resolve(name);
|
|
Files.createDirectories(JMODS_DIR);
|
|
Path outfile = JMODS_DIR.resolve(name + ".jmod");
|
|
List<String> args = new ArrayList<>();
|
|
args.add("create");
|
|
// add classes
|
|
args.add("--class-path");
|
|
args.add(mclasses.toString());
|
|
// man pages
|
|
if (manPages.size() > 0) {
|
|
args.add("--man-pages");
|
|
args.add(MAN_DIR.resolve(name).toString());
|
|
}
|
|
// header files
|
|
if (headerFiles.size() > 0) {
|
|
args.add("--header-files");
|
|
args.add(INCLUDE_DIR.resolve(name).toString());
|
|
}
|
|
args.add(outfile.toString());
|
|
|
|
if (Files.exists(outfile))
|
|
Files.delete(outfile);
|
|
|
|
System.out.println("jmod " +
|
|
args.stream().collect(Collectors.joining(" ")));
|
|
|
|
int rc = JMOD_TOOL.run(System.out, System.out,
|
|
args.toArray(new String[args.size()]));
|
|
if (rc != 0) {
|
|
throw new AssertionError("jmod failed: rc = " + rc);
|
|
}
|
|
return outfile;
|
|
}
|
|
}
|
|
}
|