make/jdk/src/classes/build/tools/module/ModuleInfoExtraTest.java

/*
 * Copyright (c) 2016, 2018, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package build.tools.module;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import build.tools.module.GenModuleInfoSource.Statement;

/**
 * Sanity test for GenModuleInfoSource tool
 */
public class ModuleInfoExtraTest {
    private static final Path DIR = Paths.get("gen-module-info-test");
    private static boolean verbose = false;
    public static void main(String... args) throws Exception {
        if (args.length != 0)
            verbose = true;

        GenModuleInfoSource.verbose = verbose;
        ModuleInfoExtraTest test = new ModuleInfoExtraTest("m", "m1", "m2", "m3");
        test.testModuleInfo();
        test.errorCases();
    }

    String[] moduleInfo = new String[] {
        "module m {",
        "    requires m1;",
        "    requires transitive m2;",
        "    exports p",
        "    to",
        "               // comment ... ",
        "    /* comment */ m1",
        ",",
        "       m2,m3",
        "  ;",
        "    exports q to m1;",
        "    provides s with /*   ",
        "    comment */ impl     ;    // comment",
        "    provides s1",
        "       with  ",
        "       impl1, impl2;",
        "}"
    };

    String[] moduleInfoExtra = new String[] {
        "exports q",
        "to",
        "   m2 // comment",
        "   /* comment */;",
        "   ;",
        "opens p.q ",
        "   to /* comment */ m3",
        "   , // m1",
        "   /* comment */ m4; uses p.I",
        ";   provides s1 with impl3;"
    };

    final Builder builder;
    ModuleInfoExtraTest(String name, String... modules) {
        this.builder = new Builder(name).modules(modules);
    }


    void testModuleInfo() throws IOException {
        GenModuleInfoSource source = builder.sourceFile(moduleInfo).build();
        Set<String> targetsP = new HashSet<>();
        targetsP.add("m1");
        targetsP.add("m2");
        targetsP.add("m3");

        Set<String> targetsQ = new HashSet<>();
        targetsQ.add("m1");

        Set<String> providerS = new HashSet<>();
        providerS.add("impl");

        Set<String> providerS1 = new HashSet<>();
        providerS1.add("impl1");
        providerS1.add("impl2");

        Set<String> opensPQ = new HashSet<>();

        check(source, targetsP, targetsQ, opensPQ, providerS, providerS1);

        // augment with extra
        Path file = DIR.resolve("extra");
        Files.write(file, Arrays.asList(moduleInfoExtra));
        source = builder.build(file);

        targetsQ.add("m2");
        providerS1.add("impl3");

        opensPQ.add("m3");
        check(source, targetsP, targetsQ, opensPQ, providerS, providerS1);
    }

    void check(GenModuleInfoSource source,
               Set<String> targetsP,
               Set<String> targetsQ,
               Set<String> opensPQ,
               Set<String> providerS,
               Set<String> providerS1) {
        if (verbose)
            source.moduleInfo.print(new PrintWriter(System.out, true));

        Statement export = source.moduleInfo.exports.get("p");
        if (!export.targets.equals(targetsP)) {
            throw new Error("unexpected: " + export);
        }

        export = source.moduleInfo.exports.get("q");
        if (!export.targets.equals(targetsQ)) {
            throw new Error("unexpected: " + export);
        }

        Statement provides = source.moduleInfo.provides.get("s");
        if (!provides.targets.equals(providerS)) {
            throw new Error("unexpected: " + provides);
        }

        provides = source.moduleInfo.provides.get("s1");
        if (!provides.targets.equals(providerS1)) {
            throw new Error("unexpected: " + provides);
        }
    }

    final Map<String[], String> badModuleInfos = Map.of(
        new String[] {
            "module x {",
            "   exports p1 to ",
            "           m1",
            "}"
        },                      ".*, line .*, missing semicolon.*",
        new String[] {
            "module x ",
            "   exports p1;"
        },                      ".*, line .*, missing \\{.*",
        new String[] {
            "module x {",
            "   requires m1;",
            "   requires",
            "}"
        },                      ".*, line .*, <identifier> missing.*",
        new String[] {
            "module x {",
            "   requires transitive m1",
            "}"
        },                      ".*, line .*, missing semicolon.*",
        new String[] {
            "module x {",
            "   exports p1 to m1;",
            "   exports p1 to m2;",
            "}"
        },                      ".*, line .*, multiple exports p1.*"
    );

    final Map<String[], String> badExtraFiles = Map.of(
            new String[] {
                "requires m2;"     // not allowed
            },                      ".*, line .*, cannot declare requires .*",
            new String[] {
                "exports p1 to m1;",
                "exports p2"            // missing semicolon
            },                      ".*, line .*, reach end of file.*",
            new String[] {
                "exports to m1;"        // missing <identifier>
            },                      ".*, line .*, <identifier> missing.*",
            new String[] {
                "exports p3 to m1;",
                "    m2, m3;"           // missing keyword
            },                      ".*, line .*, missing keyword.*",
            new String[] {
                "provides s with impl1;",   // typo ; should be ,
                "   impl2, impl3;"
            },                      ".*, line .*, missing keyword.*",
            new String[] {
                "uses s3",                  // missing semicolon
                "provides s3 with impl1,",
                "   impl2, impl3;"
            },                      ".*, line .*, missing semicolon.*",
            new String[] {
                "opens p1 to m1,, m2;"     // missing identifier
            },                      ".*, line .*, <identifier> missing.*"
    );

    final Map<String[], String> duplicates = Map.of(
            new String[] {
                "   exports p1 to m1, m2;",
                "   exports p1 to m3;",
            },                      ".*, line .*, multiple exports p1.*",
            new String[] {
                "   opens p1 to m1, m2;",
                "   exports p1 to m3;",
                "   opens p1 to m3;"
            },                      ".*, line .*, multiple opens p1.*",
            new String[] {
                "   uses s;",
                "   uses s;"
            },                      ".*, line .*, multiple uses s.*",
            new String[] {
                "   provides s with impl1;",
                "   provides s with impl2, impl3;"
            },                      ".*, line .*, multiple provides s.*"
    );

    void errorCases() {
        badModuleInfos.entrySet().stream().forEach(e -> badModuleInfoFile(e.getKey(), e.getValue()));
        badExtraFiles.entrySet().stream().forEach(e -> badExtraFile(e.getKey(), e.getValue()));
        duplicates.entrySet().stream().forEach(e -> badExtraFile(e.getKey(), e.getValue()));
    }

    void badModuleInfoFile(String[] lines, String regex)  {
        Builder builder = new Builder("x").modules("m1", "m2", "m3");
        try {
            GenModuleInfoSource source = builder.sourceFile(lines).build();
            throw new RuntimeException("Expected error: " + Arrays.toString(lines));
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        } catch (Error e) {
            if (!e.getMessage().matches(regex)) {
                throw e;
            }
        }
    }

    void badExtraFile(String[] extras, String regex)  {
        Path file = DIR.resolve("test1");
        try {
            Files.write(file, Arrays.asList(extras));
            builder.build(file);
            Files.deleteIfExists(file);
            throw new RuntimeException("Expected error: " + Arrays.toString(extras));
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        } catch (Error e) {
            if (!e.getMessage().matches(regex)) {
                throw e;
            }
        }
    }

    static class Builder {
        final String moduleName;
        final Path sourceFile;
        final Set<String> modules = new HashSet<>();
        public Builder(String name) {
            this.moduleName = name;
            this.sourceFile = DIR.resolve(name).resolve("module-info.java");
        }

        public Builder modules(String... names) {
            Arrays.stream(names).forEach(modules::add);
            return this;
        }

        public Builder sourceFile(String... lines) throws IOException {
            Files.createDirectories(sourceFile.getParent());
            try (BufferedWriter bw = Files.newBufferedWriter(sourceFile);
                 PrintWriter writer = new PrintWriter(bw)) {
                for (String l : lines) {
                    writer.println(l);
                }
            }
            return this;
        }

        public GenModuleInfoSource build() throws IOException {
            return build(Collections.emptyList());
        }

        public GenModuleInfoSource build(Path extraFile) throws IOException {
            return build(Collections.singletonList(extraFile));
        }

        public GenModuleInfoSource build(List<Path> extraFiles) throws IOException {
            return new GenModuleInfoSource(sourceFile, extraFiles, modules);
        }
    }

}