/*

 * 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 8147801

 * @summary java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9

 * @modules jdk.javadoc/com.sun.tools.javadoc

 * @library jarsrc

 * @build lib.* p.*

 * @run main T8147801

 */

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.nio.file.ClosedFileSystemException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.List;

import java.util.jar.JarEntry;

import java.util.jar.JarOutputStream;

import java.util.stream.Stream;

import com.sun.javadoc.ClassDoc;

import com.sun.javadoc.FieldDoc;

import com.sun.javadoc.RootDoc;

/*

 * This test verifies the use of the hidden fileManager.deferClose

 * option, to work around the limitation that javadoc objects

 * (like RootDoc and related types) should cannot normally be used

 * after javadoc exits, closing its file manager (if it opened it.)

 *

 * The test runs javadoc on a chain of classes, 1 in source form,

 * and 2 in a jar file. javadoc/javac will "complete" classes found

 * in source, but will eagerly "classes" in class form.

 * The chain is p/Test.java -> lib/Lib1.class -> lib/Lib2.class.

 * After javadoc exits, the classes are examined, to finally force

 * the classes to be completed, possibly causing javac to try and access

 * references into a .jar file system which has now been closed.

 *

 * The test runs two test cases -- one without the workaround option,

 * to test the validity of the test case, and one with the workaround

 * option, to test that it works as expected.

 */

public class T8147801 {

    public static void main(String... args) throws Exception {

        new T8147801().run();

    }

    void run() throws Exception {

        initJar();

        test(false);

        test(true);

        if (errors > 0) {

            throw new Exception(errors + " errors occurred");

        }

    }

    void test(boolean withOption) {

        System.err.println("Testing " + (withOption ? "with" : "without") + " option");

        try {

            String dump = "";

            RootDoc root = getRootDoc(withOption);

            for (ClassDoc cd: root.specifiedClasses()) {

                dump += dump(cd);

            }

            if (dump.contains("lib.Lib2.i")) {

                if (!withOption) {

                    error("control case failed: Lib2 class file was read, unexpectedly, without using option");

                }

            } else {

                if (withOption) {

                    error("test case failed: could not read Lib2 class file, using option");

                }

            }

        } catch (ClosedFileSystemException e) {

            error("Unexpected exception: " + e);

        }

        System.err.println();

    }

    RootDoc getRootDoc(boolean withOption) {

        List<String> opts = new ArrayList<>();

        if (withOption)

            opts.add("-XDfileManager.deferClose=10");

        opts.add("-doclet");

        opts.add(getClass().getName());

        opts.add("-classpath");

        opts.add(jarPath.toString());

        opts.add(Paths.get(System.getProperty("test.src"), "p", "Test.java").toString());

        System.err.println("javadoc opts: " + opts);

        int rc = com.sun.tools.javadoc.Main.execute(

                "javadoc",

                // by specifying our own class loader, we get the same Class instance as this

                getClass().getClassLoader(),

                opts.toArray(new String[opts.size()]));

        if (rc != 0) {

            error("unexpected exit from javadoc or doclet: " + rc);

        }

        return cachedRoot;

    }

    String dump(ClassDoc cd) {

        StringWriter sw = new StringWriter();

        PrintWriter pw = new PrintWriter(sw);

        dump(pw, "", cd);

        String out = sw.toString();

        System.err.println(out);

        return out;

    }

    void dump(PrintWriter out, String prefix, ClassDoc cd) {

        out.println(prefix + "class: " + cd);

        for (FieldDoc fd: cd.fields()) {

            out.println(prefix + "  " + fd);

            if (fd.type().asClassDoc() != null) {

                dump(out, prefix + "    ", fd.type().asClassDoc());

            }

        }

    }

    void initJar() throws IOException {

        String testClassPath = System.getProperty("test.class.path", "");

        Path jarsrc = Stream.of(testClassPath.split(File.pathSeparator))

                .map(Paths::get)

                .filter(e -> e.endsWith("jarsrc"))

                .findAny()

                .orElseThrow(() -> new InternalError("jarsrc not found"));

        jarPath = Paths.get("lib.jar");

        try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(jarPath))) {

            String[] classNames = {"Lib1.class", "Lib2.class"};

            for (String cn : classNames) {

                out.putNextEntry(new JarEntry("lib/" + cn));

                Path libClass = jarsrc.resolve("lib").resolve(cn);

                out.write(Files.readAllBytes(libClass));

            }

        }

    }

    void error(String msg) {

        System.err.println("Error: " + msg);

        errors++;

    }

    Path jarPath;

    int errors;

    // Bad doclet caches the RootDoc for later use

    static RootDoc cachedRoot;

    public static boolean start(RootDoc root) {

        cachedRoot = root;

        return true;

    }

}