test/langtools/tools/javac/file/ExplodedImage.java

/*
 * 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
 * @bug 8067138
 * @summary Verify that compiling against the exploded JDK image works, and that Locations close
 *          the directory streams properly when working with exploded JDK image.
 * @library /tools/lib
 * @modules jdk.compiler/com.sun.tools.javac.api
 *          jdk.compiler/com.sun.tools.javac.code
 *          jdk.compiler/com.sun.tools.javac.main
 * @build toolbox.ToolBox ExplodedImage
 * @run main/othervm ExplodedImage modules/* testDirectoryStreamClosed
 * @run main/othervm ExplodedImage modules/* testCanCompileAgainstExplodedImage
 */

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.nio.file.DirectoryStream;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;

import com.sun.source.util.JavacTask;
import com.sun.tools.javac.code.Symbol.ClassSymbol;

import toolbox.ToolBox;

public class ExplodedImage {
    public static void main(String... args) throws IOException {
        new ExplodedImage().run(args);
    }

    void run(String... args) throws IOException {
        switch (args[0]) {
            case "testDirectoryStreamClosed":
                testDirectoryStreamClosed(args[1]);
                break;
            case "testCanCompileAgainstExplodedImage":
                testCanCompileAgainstExplodedImage(args[1]);
                break;
        }
    }

    void testDirectoryStreamClosed(String loc) throws IOException {
        System.err.println("testDirectoryStreamClosed(" + loc + ")");
        Path javaHome = prepareJavaHome();
        Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));
        Path testClass = targetPath.resolve(("java/lang/" + TEST_FILE).replace("/", sep));
        Files.createDirectories(testClass.getParent());
        Files.createFile(testClass);
        System.setProperty("java.home", javaHome.toString());

        for (int i = 0; i < REPEATS; i++) {
            try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
                Iterable<JavaFileObject> javaLangContent =
                        fm.list(StandardLocation.PLATFORM_CLASS_PATH,
                                "java.lang",
                                EnumSet.allOf(JavaFileObject.Kind.class),
                                false);
                boolean found = false;

                for (JavaFileObject fo : javaLangContent) {
                    if (!fo.getName().endsWith(TEST_FILE)) {
                        throw new IllegalStateException("Wrong file: " + fo);
                    }
                    found = true;
                }

                if (!found)
                    throw new IllegalStateException("Could not find the expected file!");
            }
        }

        System.err.println("finished.");
    }
    //where:
        static final String TEST_FILE = "ExplodedImageTestFile.class";
        static final int REPEATS = 16 * 1024 + 1;

    void testCanCompileAgainstExplodedImage(String loc) throws IOException {
        System.err.println("testCanCompileAgainstExplodedImage(" + loc + ")");
        Path javaHome = prepareJavaHome();
        Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));
        try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
            for (String pack : REQUIRED_PACKAGES) {
                Iterable<JavaFileObject> content = fm.list(StandardLocation.PLATFORM_CLASS_PATH,
                                                           pack,
                                                           EnumSet.allOf(JavaFileObject.Kind.class),
                                                           false);

                for (JavaFileObject jfo : content) {
                    String name = jfo.getName();
                    int lastSlash = name.lastIndexOf('/');
                    name = lastSlash >= 0 ? name.substring(lastSlash + 1) : name;
                    Path target = targetPath.resolve(pack.replace(".", sep) + sep + name);
                    Files.createDirectories(target.getParent());
                    try (InputStream in = jfo.openInputStream()) {
                        Files.copy(in, target);
                    }
                }
            }
        }

        System.setProperty("java.home", javaHome.toString());

        try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
            DiagnosticListener<JavaFileObject> noErrors = d -> {
                if (d.getKind() == Diagnostic.Kind.ERROR)
                    throw new IllegalStateException("Unexpected error: " + d);
            };
            ToolBox.JavaSource inputFile =
                    new ToolBox.JavaSource("import java.util.List; class Test { List l; }");
            List<JavaFileObject> inputFiles = Arrays.asList(inputFile);
            boolean result =
                    javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles).call();
            if (!result) {
                throw new IllegalStateException("Could not compile correctly!");
            }
            JavacTask task =
                    (JavacTask) javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles);
            task.parse();
            TypeElement juList = task.getElements().getTypeElement("java.util.List");
            if (juList == null)
                throw new IllegalStateException("Cannot resolve java.util.List!");
            URI listSource = ((ClassSymbol) juList).classfile.toUri();
            if (!listSource.toString().startsWith(javaHome.toUri().toString()))
                throw new IllegalStateException(  "Did not load java.util.List from correct place, " +
                                                  "actual location: " + listSource.toString() +
                                                "; expected prefix: " + javaHome.toUri());
        }

        System.err.println("finished.");
    }
    //where:
        static final String[] REQUIRED_PACKAGES = {"java.lang", "java.io", "java.util"};

    Path prepareJavaHome() throws IOException {
        Path javaHome = new File("javahome").getAbsoluteFile().toPath();
        delete(javaHome);
        Files.createDirectory(javaHome);
        return javaHome;
    }

    String sep = FileSystems.getDefault().getSeparator();
    JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
    String originalJavaHome = System.getProperty("java.home");

    void delete(Path p) throws IOException {
        if (!Files.exists(p))
            return ;
        if (Files.isDirectory(p)) {
            try (DirectoryStream<Path> dir = Files.newDirectoryStream(p)) {
                for (Path child : dir) {
                    delete(child);
                }
            }
        }
        Files.delete(p);
    }
}