jdk-24/jdk/test/java/lang/module/ModuleDescriptorTest.java

/*
 * Copyright (c) 2013, 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
 * @run testng ModuleDescriptorTest
 * @summary Basic test for java.lang.module.ModuleDescriptor and its builder
 */

import java.io.IOException;
import java.io.InputStream;
import java.lang.module.InvalidModuleDescriptorException;
import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleDescriptor.Builder;
import java.lang.module.ModuleDescriptor.Exports;
import java.lang.module.ModuleDescriptor.Requires;
import java.lang.module.ModuleDescriptor.Provides;
import java.lang.module.ModuleDescriptor.Requires.Modifier;
import java.lang.module.ModuleDescriptor.Version;
import java.lang.reflect.Module;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import static java.lang.module.ModuleDescriptor.Requires.Modifier.*;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;

@Test
public class ModuleDescriptorTest {

    @DataProvider(name = "invalidjavaidentifiers")
    public Object[][] invalidJavaIdentifiers() {
        return new Object[][]{

            { null,         null },
            { ".foo",       null },
            { "foo.",       null },
            { "[foo]",      null },

        };
    }


    // requires

    private Requires requires(Set<Modifier> mods, String mn) {
        return new Builder("m")
            .requires(mods, mn)
            .build()
            .requires()
            .iterator()
            .next();
    }

    public void testRequiresWithRequires() {
        Requires r1 = requires(null, "foo");
        ModuleDescriptor descriptor = new Builder("m").requires(r1).build();
        Requires r2 = descriptor.requires().iterator().next();
        assertEquals(r1, r2);
    }

    public void testRequiresWithNullModifiers() {
        Requires r = requires(null, "foo");
        assertEquals(r, r);
        assertTrue(r.compareTo(r) == 0);
        assertTrue(r.modifiers().isEmpty());
        assertEquals(r.name(), "foo");
    }

    public void testRequiresWithNoModifiers() {
        Requires r = requires(EnumSet.noneOf(Requires.Modifier.class), "foo");
        assertEquals(r, r);
        assertTrue(r.compareTo(r) == 0);
        assertTrue(r.modifiers().isEmpty());
        assertEquals(r.name(), "foo");
    }

    public void testRequiresWithOneModifier() {
        Requires r = requires(EnumSet.of(PUBLIC), "foo");
        assertEquals(r, r);
        assertTrue(r.compareTo(r) == 0);
        assertEquals(r.modifiers(), EnumSet.of(PUBLIC));
        assertEquals(r.name(), "foo");
    }

    public void testRequiresWithTwoModifiers() {
        Requires r = requires(EnumSet.of(PUBLIC, SYNTHETIC), "foo");
        assertEquals(r, r);
        assertTrue(r.compareTo(r) == 0);
        assertEquals(r.modifiers(), EnumSet.of(PUBLIC, SYNTHETIC));
        assertEquals(r.name(), "foo");
    }

    public void testRequiresWithAllModifiers() {
        Requires r = requires(EnumSet.allOf(Modifier.class), "foo");
        assertEquals(r, r);
        assertTrue(r.compareTo(r) == 0);
        assertEquals(r.modifiers(), EnumSet.allOf(Modifier.class));
        assertEquals(r.name(), "foo");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testRequiresWithDuplicatesRequires() {
        Requires r = requires(null, "foo");
        new Builder("m").requires(r).requires(r);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testRequiresSelfWithRequires() {
        Requires r = requires(null, "m");
        new Builder("m").requires(r);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testRequiresSelfWithNoModifier() {
        new Builder("m").requires("m");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testRequiresSelfWithOneModifier() {
        new Builder("m").requires(PUBLIC, "m");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testRequiresSelfWithAllModifiers() {
        new Builder("m").requires(EnumSet.allOf(Modifier.class), "m");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testRequiresWithBadModuleName(String mn, String ignore) {
        requires(EnumSet.noneOf(Modifier.class), mn);
    }

    @Test(expectedExceptions = NullPointerException.class)
    public void testRequiresWithNullRequires() {
        new Builder("m").requires((Requires) null);
    }

    public void testRequiresCompare() {
        Requires r1 = requires(EnumSet.noneOf(Modifier.class), "foo");
        Requires r2 = requires(EnumSet.noneOf(Modifier.class), "bar");
        int n = "foo".compareTo("bar");
        assertTrue(r1.compareTo(r2) == n);
        assertTrue(r2.compareTo(r1) == -n);
    }

    public void testRequiresToString() {
        Requires r = requires(EnumSet.noneOf(Modifier.class), "foo");
        assertTrue(r.toString().contains("foo"));
    }


    // exports

    private Exports exports(String pn) {
        return new Builder("foo")
            .exports(pn)
            .build()
            .exports()
            .iterator()
            .next();
    }

    private Exports exports(String pn, String target) {
        return new Builder("foo")
            .exports(pn, target)
            .build()
            .exports()
            .iterator()
            .next();
    }

    public void testExportsExports() {
        Exports e1 = exports("p");
        ModuleDescriptor descriptor = new Builder("m").exports(e1).build();
        Exports e2 = descriptor.exports().iterator().next();
        assertEquals(e1, e2);
    }

    public void testExportsToAll() {
        Exports e = exports("p");
        assertEquals(e, e);
        assertEquals(e.source(), "p");
        assertFalse(e.isQualified());
        assertTrue(e.targets().isEmpty());
    }

    public void testExportsToTarget() {
        Exports e = exports("p", "bar");
        assertEquals(e, e);
        assertEquals(e.source(), "p");
        assertTrue(e.isQualified());
        assertTrue(e.targets().size() == 1);
        assertTrue(e.targets().contains("bar"));
    }

    public void testExportsToTargets() {
        Set<String> targets = new HashSet<>();
        targets.add("bar");
        targets.add("gus");
        Exports e
            = new Builder("foo")
                .exports("p", targets)
                .build()
                .exports()
                .iterator()
                .next();
        assertEquals(e, e);
        assertEquals(e.source(), "p");
        assertTrue(e.isQualified());
        assertTrue(e.targets().size() == 2);
        assertTrue(e.targets().contains("bar"));
        assertTrue(e.targets().contains("gus"));
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testExportsWithDuplicate1() {
        Exports e = exports("p");
        new Builder("foo").exports(e).exports(e);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testExportsWithDuplicate2() {
        new Builder("foo").exports("p").exports("p");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testExportsWithConcealedPackage() {
        new Builder("foo").conceals("p").exports("p");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testExportsToTargetWithConcealedPackage() {
        new Builder("foo").conceals("p").exports("p", "bar");
    }

    @Test(expectedExceptions = IllegalArgumentException.class )
    public void testExportsWithEmptySet() {
        new Builder("foo").exports("p", Collections.emptySet());
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testExportsWithBadName(String pn, String ignore) {
        new Builder("foo").exports(pn);
    }

    @Test(expectedExceptions = NullPointerException.class )
    public void testExportsWithNullExports() {
        new Builder("foo").exports((Exports)null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class )
    public void testExportsWithNullTarget() {
        new Builder("foo").exports("p", (String) null);
    }

    @Test(expectedExceptions = NullPointerException.class )
    public void testExportsWithNullTargets() {
        new Builder("foo").exports("p", (Set<String>) null);
    }

    public void testExportsToString() {
        String s = new Builder("foo")
            .exports("p1", "bar")
            .build()
            .exports()
            .iterator()
            .next()
            .toString();
        assertTrue(s.contains("p1"));
        assertTrue(s.contains("bar"));
    }


    // uses

    public void testUses() {
        Set<String> uses
            = new Builder("foo")
                .uses("p.S")
                .uses("q.S")
                .build()
                .uses();
        assertTrue(uses.size() == 2);
        assertTrue(uses.contains("p.S"));
        assertTrue(uses.contains("q.S"));
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testUsesWithDuplicate() {
        new Builder("foo").uses("p.S").uses("p.S");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testUsesWithBadName(String service, String ignore) {
        new Builder("foo").uses(service);
    }


    // provides

    private Provides provides(String st, String pc) {
        return new Builder("foo")
            .provides("p.S", pc)
            .build()
            .provides()
            .values()
            .iterator()
            .next();
    }

    public void testProvidesWithProvides() {
        Provides p1 = provides("p.S", "q.S1");
        ModuleDescriptor descriptor = new Builder("m").provides(p1).build();
        Provides p2 = descriptor.provides().get("p.S");
        assertEquals(p1, p2);
    }

    public void testProvides() {
        Set<String> pns = new HashSet<>();
        pns.add("q.P1");
        pns.add("q.P2");

        Map<String, Provides> map
            = new Builder("foo")
                .provides("p.S", pns)
                .build()
                .provides();
        assertTrue(map.size() == 1);

        Provides p = map.values().iterator().next();
        assertEquals(p, p);
        assertTrue(p.providers().size() == 2);
        assertTrue(p.providers().contains("q.P1"));
        assertTrue(p.providers().contains("q.P2"));
    }

    @Test(expectedExceptions = IllegalStateException.class )
    public void testProvidesWithDuplicateProvides() {
        Provides p = provides("p.S", "q.S2");
        new Builder("m").provides("p.S", "q.S1").provides(p);
    }

    @Test(expectedExceptions = IllegalArgumentException.class )
    public void testProvidesWithEmptySet() {
        new Builder("foo").provides("p.Service", Collections.emptySet());
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testProvidesWithBadService(String service, String ignore) {
        new Builder("foo").provides(service, "p.Provider");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testProvidesWithBadProvider(String provider, String ignore) {
        new Builder("foo").provides("p.Service", provider);
    }

    @Test(expectedExceptions = NullPointerException.class )
    public void testProvidesWithNullProvides() {
        new Builder("foo").provides((Provides)null);
    }

    @Test(expectedExceptions = NullPointerException.class )
    public void testProvidesWithNullProviders() {
        new Builder("foo").provides("p.S", (Set<String>) null);
    }


    // conceals

    public void testConceals() {
        Set<String> conceals
            = new Builder("foo").conceals("p").conceals("q").build().conceals();
        assertTrue(conceals.size() == 2);
        assertTrue(conceals.contains("p"));
        assertTrue(conceals.contains("q"));
    }

    public void testConcealsWithEmptySet() {
        Set<String> conceals
            = new Builder("foo").conceals(Collections.emptySet()).build().conceals();
        assertTrue(conceals.size() == 0);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testConcealsWithDuplicate() {
        new Builder("foo").conceals("p").conceals("p");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testConcealsWithExportedPackage() {
        new Builder("foo").exports("p").conceals("p");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testConcealsWithBadName(String pn, String ignore) {
        new Builder("foo").conceals(pn);
    }


    // packages

    public void testPackages() {
        Set<String> packages
            = new Builder("foo").exports("p").conceals("q").build().packages();
        assertTrue(packages.size() == 2);
        assertTrue(packages.contains("p"));
        assertTrue(packages.contains("q"));
    }


    // name

    public void testModuleName() {
        String mn = new Builder("foo").build().name();
        assertEquals(mn, "foo");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testBadModuleName(String mn, String ignore) {
        new Builder(mn);
    }


    // version

    public void testVersion1() {
        Version v1 = Version.parse("1.0");
        Version v2 = new Builder("foo").version(v1).build().version().get();
        assertEquals(v1, v2);
    }

    public void testVersion2() {
        String vs = "1.0";
        Version v1 = new Builder("foo").version(vs).build().version().get();
        Version v2 = Version.parse(vs);
        assertEquals(v1, v2);
    }

    @Test(expectedExceptions = NullPointerException.class )
    public void testNullVersion1() {
        new Builder("foo").version((Version)null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class )
    public void testNullVersion2() {
        new Builder("foo").version((String)null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class )
    public void testEmptyVersion() {
        new Builder("foo").version("");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateVersion1() {
        Version v = Version.parse("2.0");
        new Builder("foo").version("1.0").version(v);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateVersion2() {
        new Builder("foo").version("1.0").version("2.0");
    }


    // toNameAndVersion

    public void testToNameAndVersion() {
        ModuleDescriptor md1 = new Builder("foo").build();
        assertEquals(md1.toNameAndVersion(), "foo");

        ModuleDescriptor md2 = new Builder("foo").version("1.0").build();
        assertEquals(md2.toNameAndVersion(), "foo@1.0");
    }


    // isAutomatic
    public void testIsAutomatic() {
        ModuleDescriptor descriptor = new Builder("foo").build();
        assertFalse(descriptor.isAutomatic());
    }

    // isSynthetic
    public void testIsSynthetic() {
        assertFalse(Object.class.getModule().getDescriptor().isSynthetic());

        ModuleDescriptor descriptor = new Builder("foo").build();
        assertFalse(descriptor.isSynthetic());
    }


    // mainClass

    public void testMainClass() {
        String mainClass
            = new Builder("foo").mainClass("p.Main").build().mainClass().get();
        assertEquals(mainClass, "p.Main");
    }

    @Test(dataProvider = "invalidjavaidentifiers",
          expectedExceptions = IllegalArgumentException.class )
    public void testMainClassWithBadName(String mainClass, String ignore) {
        Builder builder = new Builder("foo");
        builder.mainClass(mainClass);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateMainClass() {
        new Builder("foo").mainClass("p.Main").mainClass("p.Main");
    }


    // osName

    public void testOsName() {
        String osName = new Builder("foo").osName("Linux").build().osName().get();
        assertEquals(osName, "Linux");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullOsName() {
        new Builder("foo").osName(null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testEmptyOsName() {
        new Builder("foo").osName("");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateOsName() {
        new Builder("foo").osName("Linux").osName("Linux");
    }


    // osArch

    public void testOsArch() {
        String osArch = new Builder("foo").osName("arm").build().osName().get();
        assertEquals(osArch, "arm");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullOsArch() {
        new Builder("foo").osArch(null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testEmptyOsArch() {
        new Builder("foo").osArch("");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateOsArch() {
        new Builder("foo").osArch("arm").osArch("arm");
    }


    // osVersion

    public void testOsVersion() {
        String osVersion = new Builder("foo").osName("11.2").build().osName().get();
        assertEquals(osVersion, "11.2");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullOsVersion() {
        new Builder("foo").osVersion(null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testEmptyOsVersion() {
        new Builder("foo").osVersion("");
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testDuplicateOsVersion() {
        new Builder("foo").osVersion("11.2").osVersion("11.2");
    }


    // reads

    private static InputStream EMPTY_INPUT_STREAM = new InputStream() {
        @Override
        public int read() {
            return -1;
        }
    };

    private static InputStream FAILING_INPUT_STREAM = new InputStream() {
        @Override
        public int read() throws IOException {
            throw new IOException();
        }
    };

    public void testRead() throws Exception {
        Module base = Object.class.getModule();

        try (InputStream in = base.getResourceAsStream("module-info.class")) {
            ModuleDescriptor descriptor = ModuleDescriptor.read(in);
            assertTrue(in.read() == -1); // all bytes read
            assertEquals(descriptor.name(), "java.base");
        }

        try (InputStream in = base.getResourceAsStream("module-info.class")) {
            ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
            ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
            assertFalse(bb.hasRemaining()); // no more remaining bytes
            assertEquals(descriptor.name(), "java.base");
        }
    }

    public void testReadsWithPackageFinder() {
        // TBD: Need way to write a module-info.class without a
        // ConcealedPackages attribute
    }

    @Test(expectedExceptions = InvalidModuleDescriptorException.class)
    public void testReadFromEmptyInputStream() throws Exception {
        ModuleDescriptor.read(EMPTY_INPUT_STREAM);
    }

    @Test(expectedExceptions = IOException.class)
    public void testReadFromFailingInputStream() throws Exception {
        ModuleDescriptor.read(FAILING_INPUT_STREAM);
    }

    @Test(expectedExceptions = InvalidModuleDescriptorException.class)
    public void testReadFromEmptyBuffer() {
        ByteBuffer bb = ByteBuffer.allocate(0);
        ModuleDescriptor.read(bb);
    }

    public void testReadWithNull() throws Exception {
        Module base = Object.class.getModule();

        try {
            ModuleDescriptor.read((InputStream)null);
            assertTrue(false);
        } catch (NullPointerException expected) { }


        try (InputStream in = base.getResourceAsStream("module-info.class")) {
            try {
                ModuleDescriptor.read(in, null);
                assertTrue(false);
            } catch (NullPointerException expected) { }
        }

        try {
            ModuleDescriptor.read((ByteBuffer)null);
            assertTrue(false);
        } catch (NullPointerException expected) { }


        try (InputStream in = base.getResourceAsStream("module-info.class")) {
            ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
            try {
                ModuleDescriptor.read(bb, null);
                assertTrue(false);
            } catch (NullPointerException expected) { }
        }
    }


    // equals/hashCode/compareTo/toString

    public void testEqualsAndHashCode() {
        ModuleDescriptor md1 = new Builder("foo").build();
        ModuleDescriptor md2 = new Builder("foo").build();
        assertEquals(md1, md1);
        assertEquals(md1.hashCode(), md2.hashCode());
    }

    public void testCompare() {
        ModuleDescriptor md1 = new Builder("foo").build();
        ModuleDescriptor md2 = new Builder("bar").build();
        int n = "foo".compareTo("bar");
        assertTrue(md1.compareTo(md2) == n);
        assertTrue(md2.compareTo(md1) == -n);
    }

    public void testToString() {
        String s = new Builder("m1").requires("m2").exports("p1").build().toString();
        assertTrue(s.contains("m1"));
        assertTrue(s.contains("m2"));
        assertTrue(s.contains("p1"));
    }

}