/*
 * Copyright (c) 2024, 2025, 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 8328481 8332236 8332890 8344647 8347646
 * @summary Check behavior of module imports.
 * @library /tools/lib
 * @modules java.logging
 *          java.sql
 *          jdk.compiler/com.sun.tools.javac.api
 *          jdk.compiler/com.sun.tools.javac.main
 *          jdk.compiler/com.sun.tools.javac.util
 * @build toolbox.ToolBox toolbox.JavacTask
 * @run main ImportModule
 */

import com.sun.source.tree.Tree;
import com.sun.source.util.TaskEvent;
import com.sun.source.util.TaskEvent.Kind;
import com.sun.source.util.TaskListener;
import java.lang.classfile.ClassFile;
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.Objects;

import toolbox.TestRunner;
import toolbox.JavacTask;
import toolbox.JavaTask;
import toolbox.Task;
import toolbox.ToolBox;

public class ImportModule extends TestRunner {

    private static final String SOURCE_VERSION = System.getProperty("java.specification.version");
    private ToolBox tb;

    public static void main(String... args) throws Exception {
        new ImportModule().runTests();
    }

    ImportModule() {
        super(System.err);
        tb = new ToolBox();
    }

    public void runTests() throws Exception {
        runTests(m -> new Object[] { Paths.get(m.getName()) });
    }

    @Test
    public void testImportJavaBase(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          public class Test {
                              public static void main(String... args) {
                                  List<String> l = new ArrayList<>();
                                  System.out.println(l.getClass().getName());
                              }
                          }
                          """);

        Files.createDirectories(classes);

        {//with --release:
            new JavacTask(tb)
                .outdir(classes)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.SUCCESS)
                .writeAll();

            var out = new JavaTask(tb)
                    .classpath(classes.toString())
                    .className("test.Test")
                    .run()
                    .writeAll()
                    .getOutputLines(Task.OutputKind.STDOUT);

            var expectedOut = List.of("java.util.ArrayList");

            if (!Objects.equals(expectedOut, out)) {
                throw new AssertionError("Incorrect Output, expected: " + expectedOut +
                                          ", actual: " + out);

            }
        }

        {//with --source:
            new JavacTask(tb)
                .outdir(classes)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.SUCCESS)
                .writeAll();

            var out = new JavaTask(tb)
                    .classpath(classes.toString())
                    .className("test.Test")
                    .run()
                    .writeAll()
                    .getOutputLines(Task.OutputKind.STDOUT);

            var expectedOut = List.of("java.util.ArrayList");

            if (!Objects.equals(expectedOut, out)) {
                throw new AssertionError("Incorrect Output, expected: " + expectedOut +
                                          ", actual: " + out);

            }
        }
    }

    @Test
    public void testVerifySourceLevelCheck(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          public class Test {
                          }
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors;
        List<String> expectedErrors;

        actualErrors =
                new JavacTask(tb)
                    .options("--release", "24", "-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test.java:2:8: compiler.err.feature.not.supported.in.source.plural: (compiler.misc.feature.module.imports), 24, 25",
                "1 error"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + actualErrors);

        }

        new JavacTask(tb)
            .options("-XDrawDiagnostics")
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run()
            .writeAll();
    }

    @Test
    public void testConflicts(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.logging;
                          import java.lang.System.*;
                          public class Test {
                              Logger l;
                          }
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors;
        List<String> expectedErrors;

        new JavacTask(tb)
            .options("-XDrawDiagnostics")
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run(Task.Expect.SUCCESS)
            .writeAll()
            .getOutputLines(Task.OutputKind.DIRECT);

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.logging;
                          import java.lang.System.*;
                          import java.lang.System.Logger;
                          public class Test {
                              Logger l;
                          }
                          """);

        new JavacTask(tb)
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run()
            .writeAll();

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.logging;
                          import java.lang.System.*;
                          import java.util.logging.Logger;
                          public class Test {
                              Logger l;
                          }
                          """);

        new JavacTask(tb)
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run()
            .writeAll();

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.logging;
                          import java.lang.System.*;
                          public class Test {
                          }
                          """);

        new JavacTask(tb)
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run()
            .writeAll();

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          import module java.sql;
                          public class Test {
                              Date d;
                          }
                          """);

        actualErrors =
                new JavacTask(tb)
                    .options("-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test.java:5:5: compiler.err.ref.ambiguous: Date, kindname.class, java.sql.Date, java.sql, kindname.class, java.util.Date, java.util",
                "1 error"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + out);

        }

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          import module java.sql;
                          import java.util.Date;
                          public class Test {
                              Date d;
                          }
                          """);

        new JavacTask(tb)
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run()
            .writeAll();
    }

    @Test
    public void testNoQualifiedExports(Path base) throws Exception {
        Path current = base.resolve(".");

        Path lib = current.resolve("lib");
        Path libSrc = lib.resolve("src");
        Path libClasses = lib.resolve("classes");
        tb.writeJavaFiles(libSrc,
                          """
                          module lib {
                              exports api;
                              exports impl to use;
                          }
                          """,
                          """
                          package api;
                          public class Api {
                          }
                          """,
                          """
                          package impl;
                          public class Impl {
                          }
                          """);

        Files.createDirectories(libClasses);

        new JavacTask(tb)
            .outdir(libClasses)
            .files(tb.findJavaFiles(libSrc))
            .run()
            .writeAll();

        Path src = current.resolve("src");
        Path classes = current.resolve("classes");

        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module lib;
                          public class Test {
                              public static void main(String... args) {
                                  Api a;
                                  Impl i;
                              }
                          }
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors;
        List<String> expectedErrors;

        actualErrors =
                new JavacTask(tb)
                    .options("-p", libClasses.toString(),
                             "--add-modules", "lib",
                             "-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test.java:6:9: compiler.err.cant.resolve.location: kindname.class, Impl, , , (compiler.misc.location: kindname.class, test.Test, null)",
                "1 error"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + out);

        }

        actualErrors =
                new JavacTask(tb)
                    .options("-p", libClasses.toString(),
                             "-XDdev",
                             "-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test.java:2:1: compiler.err.import.module.does.not.read.unnamed: lib",
                "Test.java:6:9: compiler.err.cant.resolve.location: kindname.class, Impl, , , (compiler.misc.location: kindname.class, test.Test, null)",
                "2 errors"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + out);

        }

        tb.writeJavaFiles(src,
                          """
                          module test.module {
                          }
                          """);

        actualErrors =
                new JavacTask(tb)
                    .options("-p", libClasses.toString(),
                             "-XDdev",
                             "-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test.java:2:1: compiler.err.import.module.does.not.read: test.module, lib",
                "Test.java:6:9: compiler.err.cant.resolve.location: kindname.class, Impl, , , (compiler.misc.location: kindname.class, test.Test, null)",
                "2 errors"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + out);

        }
    }

    @Test
    public void testTransitiveDependencies(Path base) throws Exception {
        Path current = base.resolve(".");
        Path lib = current.resolve("lib");
        Path libSrc = lib.resolve("src");
        Path libM1 = libSrc.resolve("m1");
        tb.writeJavaFiles(libM1,
                          """
                          module m1 {
                              requires transitive m2;
                              exports api1;
                              exports api2 to test;
                              exports api3 to m3;
                          }
                          """,
                          """
                          package api1;
                          public class Api1 {
                          }
                          """,
                          """
                          package api2;
                          public class Api2 {
                          }
                          """,
                          """
                          package api3;
                          public class Api3 {
                          }
                          """,
                          """
                          package impl1;
                          public class Impl1 {
                          }
                          """);

        Path libM2 = libSrc.resolve("m2");
        tb.writeJavaFiles(libM2,
                          """
                          module m2 {
                              exports api4;
                              exports api5 to test;
                              exports api6 to m3;
                          }
                          """,
                          """
                          package api4;
                          public class Api4 {
                          }
                          """,
                          """
                          package api5;
                          public class Api5 {
                          }
                          """,
                          """
                          package api6;
                          public class Api6 {
                          }
                          """,
                          """
                          package impl2;
                          public class Impl2 {
                          }
                          """);

        Path libClasses = lib.resolve("classes");
        Files.createDirectories(libClasses);

        new JavacTask(tb)
            .options("--module-source-path", libSrc.toString(),
                     "-XDrawDiagnostics")
            .outdir(libClasses)
            .files(tb.findJavaFiles(libSrc))
            .run()
            .writeAll();

        Path src = current.resolve("src");
        tb.writeJavaFiles(src,
                          """
                          module test {
                              requires m1;
                          }
                          """,
                          """
                          package test;
                          import module m1;
                          public class Test1 {
                              Api1 a1;
                              Api2 a2;
                              Api3 a3;
                              Impl1 i1;
                              Api4 a4;
                              Api5 a5;
                              Api6 a6;
                              Impl2 i2;
                          }
                          """,
                          """
                          package test;
                          import module m2;
                          public class Test2 {
                              Api1 a1;
                              Api2 a2;
                              Api3 a3;
                              Impl1 i1;
                              Api4 a4;
                              Api5 a5;
                              Api6 a6;
                              Impl2 i2;
                          }
                          """);

        Path classes = current.resolve("classes");
        Files.createDirectories(classes);

        List<String> actualErrors;
        List<String> expectedErrors;

        actualErrors =
                new JavacTask(tb)
                    .options("--module-path", libClasses.toString(),
                             "-XDrawDiagnostics")
                    .outdir(classes)
                    .files(tb.findJavaFiles(src))
                    .run(Task.Expect.FAIL)
                    .writeAll()
                    .getOutputLines(Task.OutputKind.DIRECT);

        expectedErrors = List.of(
                "Test1.java:6:5: compiler.err.cant.resolve.location: kindname.class, Api3, , , (compiler.misc.location: kindname.class, test.Test1, null)",
                "Test1.java:7:5: compiler.err.cant.resolve.location: kindname.class, Impl1, , , (compiler.misc.location: kindname.class, test.Test1, null)",
                "Test1.java:10:5: compiler.err.cant.resolve.location: kindname.class, Api6, , , (compiler.misc.location: kindname.class, test.Test1, null)",
                "Test1.java:11:5: compiler.err.cant.resolve.location: kindname.class, Impl2, , , (compiler.misc.location: kindname.class, test.Test1, null)",
                "Test2.java:4:5: compiler.err.cant.resolve.location: kindname.class, Api1, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "Test2.java:5:5: compiler.err.cant.resolve.location: kindname.class, Api2, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "Test2.java:6:5: compiler.err.cant.resolve.location: kindname.class, Api3, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "Test2.java:7:5: compiler.err.cant.resolve.location: kindname.class, Impl1, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "Test2.java:10:5: compiler.err.cant.resolve.location: kindname.class, Api6, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "Test2.java:11:5: compiler.err.cant.resolve.location: kindname.class, Impl2, , , (compiler.misc.location: kindname.class, test.Test2, null)",
                "10 errors"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + out);

        }
    }

    @Test
    public void testModel(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          public class Test {
                          }
                          """);

        Files.createDirectories(classes);
        List<String> kinds = new ArrayList<>();

        new JavacTask(tb)
            .outdir(classes)
            .callback(task -> {
                task.addTaskListener(new TaskListener() {
                    @Override
                    public void finished(TaskEvent e) {
                        if (e.getKind() == Kind.ANALYZE) {
                            for (Tree t : e.getCompilationUnit().getTypeDecls()) {
                                kinds.add(t.getKind().name());
                            }
                        }
                    }
                });
            })
            .files(tb.findJavaFiles(src))
            .run(Task.Expect.SUCCESS)
            .writeAll();

        List<String> expectedKinds = List.of(
            "CLASS"
        );

        if (!Objects.equals(expectedKinds, kinds)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedKinds +
                                      ", actual: " + kinds);

        }
    }

    @Test
    public void testModelDisambiguation(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module.*;
                          import module.ModuleClass;
                          import module.module.*;
                          import module.module.ModuleModuleClass;
                          public class Test {
                          }
                          """,
                          """
                          package module;
                          public class ModuleClass{
                          }
                          """,
                          """
                          package module.module;
                          public class ModuleModuleClass {
                          }
                          """);

        Files.createDirectories(classes);
        List<String> kinds = new ArrayList<>();

        new JavacTask(tb)
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run(Task.Expect.SUCCESS)
            .writeAll();
    }

    @Test
    public void testImplicitlyDeclaredClass(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeFile(src.resolve("Test.java"),
                     """
                     import module java.base;
                     void main() {
                     }
                     """);

        Files.createDirectories(classes);

        new JavacTask(tb)
            .options("--enable-preview", "--release", SOURCE_VERSION) //for implicitly declared classes
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run(Task.Expect.SUCCESS)
            .writeAll();
    }

    @Test //JDK-8332890
    public void testModuleInfoSelfImport(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          import module M;
                          module M {
                             exports p1 to M1;
                             exports p2;
                             exports p3 to M;
                             uses A;
                             uses B;
                             uses C;
                          }
                          """,
                          """
                          package p1;
                          public class A {}
                          """,
                          """
                          package p2;
                          public class B {}
                          """,
                          """
                          package p3;
                          public class C {}
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors = new JavacTask(tb)
                .options("-XDrawDiagnostics")
                .outdir(classes)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.FAIL)
                .writeAll()
                .getOutputLines(Task.OutputKind.DIRECT);

        List<String> expectedErrors = List.of(
                "module-info.java:3:18: compiler.warn.module.not.found: M1",
                "module-info.java:6:9: compiler.err.cant.resolve: kindname.class, A, , ",
                "1 error",
                "1 warning"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + actualErrors);

        }
    }

    @Test
    public void testImportModuleNoModules(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        tb.writeJavaFiles(src,
                          """
                          package test;
                          import module java.base;
                          public class Test {
                              List<String> l;
                          }
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors = new JavacTask(tb)
            .options("--release", "8",
                     "-XDshould-stop.at=FLOW",
                     "-XDdev",
                     "-XDrawDiagnostics")
            .outdir(classes)
            .files(tb.findJavaFiles(src))
            .run(Task.Expect.FAIL)
            .writeAll()
            .getOutputLines(Task.OutputKind.DIRECT);

        List<String> expectedErrors = List.of(
                "- compiler.warn.option.obsolete.source: 8",
                "- compiler.warn.option.obsolete.target: 8",
                "- compiler.warn.option.obsolete.suppression",
                "Test.java:2:8: compiler.err.feature.not.supported.in.source.plural: (compiler.misc.feature.module.imports), 8, 25",
                "Test.java:2:1: compiler.err.import.module.not.found: java.base",
                "Test.java:4:5: compiler.err.cant.resolve.location: kindname.class, List, , , (compiler.misc.location: kindname.class, test.Test, null)",
                "3 errors",
                "3 warnings"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + actualErrors);

        }
    }

    @Test
    public void testPackageImportDisambiguates(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        Path ma = src.resolve("ma");
        tb.writeJavaFiles(ma,
                          """
                          module ma {
                             exports ma.p1;
                          }
                          """,
                          """
                          package ma.p1;
                          public class A {}
                          """);
        Path mb = src.resolve("mb");
        tb.writeJavaFiles(mb,
                          """
                          module mb {
                             exports mb.p1;
                          }
                          """,
                          """
                          package mb.p1;
                          public class A {}
                          """);
        Path test = src.resolve("test");
        tb.writeJavaFiles(test,
                          """
                          module test {
                              requires ma;
                              requires mb;
                          }
                          """,
                          """
                          package test;
                          import module ma;
                          import module mb;
                          public class Test {
                              A a;
                          }
                          """);

        Files.createDirectories(classes);

        List<String> actualErrors = new JavacTask(tb)
                .options("-XDrawDiagnostics",
                         "--module-source-path", src.toString())
                .outdir(classes)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.FAIL)
                .writeAll()
                .getOutputLines(Task.OutputKind.DIRECT);

        List<String> expectedErrors = List.of(
                "Test.java:5:5: compiler.err.ref.ambiguous: A, kindname.class, mb.p1.A, mb.p1, kindname.class, ma.p1.A, ma.p1",
                "1 error"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + actualErrors);

        }

        tb.writeJavaFiles(test,
                          """
                          package test;
                          import module ma;
                          import module mb;
                          import mb.p1.*;
                          public class Test {
                              A a;
                          }
                          """);

        Files.createDirectories(classes);

        new JavacTask(tb)
                .options("-XDrawDiagnostics",
                         "--module-source-path", src.toString())
                .outdir(classes)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.SUCCESS)
                .writeAll();
    }

    @Test //JDK-8344647
    public void testJavaBaseOverride(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path javaBaseClasses = current.resolve("javaBaseClasses");
        Path javaBase = src.resolve("java.base");
        tb.writeJavaFiles(javaBase,
                          """
                          module java.base {
                             exports java.lang;
                          }
                          """,
                          """
                          package java.lang;
                          public class Object {}
                          """);

        Files.createDirectories(javaBaseClasses);

        new JavacTask(tb)
                .options("--patch-module", "java.base=" + src.toString())
                .outdir(javaBaseClasses)
                .files(tb.findJavaFiles(src))
                .run(Task.Expect.SUCCESS)
                .writeAll()
                .getOutputLines(Task.OutputKind.DIRECT);

        Path test = current.resolve("test");
        tb.writeJavaFiles(test,
                          """
                          module test {
                              requires java.se;
                          }
                          """);

        Path classes = current.resolve("classes");
        Files.createDirectories(classes);

        new JavacTask(tb)
                .options("--patch-module", "java.base=" + javaBaseClasses.toString())
                .outdir(classes)
                .files(tb.findJavaFiles(test))
                .run(Task.Expect.SUCCESS)
                .writeAll();
    }

    @Test //JDK-8347646
    public void testRequiresTransitiveJavaBase(Path base) throws Exception {
        Path current = base.resolve(".");
        Path src = current.resolve("src");
        Path classes = current.resolve("classes");
        Path ma = src.resolve("ma");
        Path maClasses = classes.resolve("ma");
        tb.writeJavaFiles(ma,
                          """
                          module ma {
                             requires transitive java.base;
                          }
                          """);
        Path test = src.resolve("test");
        tb.writeJavaFiles(test,
                          """
                          module test {
                              requires ma;
                          }
                          """,
                          """
                          package test;
                          import module ma;
                          public class Test {
                              public static void main(String... args) {
                                  System.out.println(List.of("Hello"));
                              }
                          }
                          """);

        Files.createDirectories(maClasses);

        List<String> actualErrors = new JavacTask(tb)
                .options("-XDrawDiagnostics",
                         "--release", "24")
                .outdir(maClasses)
                .files(tb.findJavaFiles(ma))
                .run(Task.Expect.FAIL)
                .writeAll()
                .getOutputLines(Task.OutputKind.DIRECT);

        List<String> expectedErrors = List.of(
                "module-info.java:2:4: compiler.err.feature.not.supported.in.source.plural: (compiler.misc.feature.java.base.transitive), 24, 25",
                "1 error"
        );

        if (!Objects.equals(expectedErrors, actualErrors)) {
            throw new AssertionError("Incorrect Output, expected: " + expectedErrors +
                                      ", actual: " + actualErrors);

        }

        new JavacTask(tb)
            .options("-XDrawDiagnostics",
                     "--source", "9")
            .outdir(maClasses)
            .files(tb.findJavaFiles(ma))
            .run()
            .writeAll();

        Path maModuleInfo = maClasses.resolve("module-info.class");

        if (ClassFile.of().parse(maModuleInfo).minorVersion() == ClassFile.PREVIEW_MINOR_VERSION) {
            throw new AssertionError("wrong minor version");
        }

        new JavacTask(tb)
            .options("-XDrawDiagnostics")
            .outdir(maClasses)
            .files(tb.findJavaFiles(ma))
            .run()
            .writeAll();

        Path maModuleInfo2 = maClasses.resolve("module-info.class");

        if (ClassFile.of().parse(maModuleInfo2).minorVersion() != 0) {
            throw new AssertionError("wrong minor version");
        }
    }
}