/*

 * Copyright (c) 2013, 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

 * @modules java.base/jdk.internal.module

 *          java.base/jdk.internal.misc

 * @run testng ModuleDescriptorTest

 * @summary Basic test for java.lang.module.ModuleDescriptor and its builder

 */

import java.io.ByteArrayOutputStream;

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.Opens;

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.nio.ByteBuffer;

import java.util.ArrayList;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import java.util.Optional;

import java.util.Set;

import java.util.stream.Collectors;

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

import jdk.internal.misc.JavaLangModuleAccess;

import jdk.internal.misc.SharedSecrets;

import jdk.internal.module.ModuleInfoWriter;

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 },

            { "1",              null },

            { "1foo",           null },

            { ".foo",           null },

            { "foo.",           null },

            { "[foo]",          null },

            { "foo.1",          null },

            { "1foo.bar",       null },

            { "foo.1bar",       null },

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

            { "foo..bar",       null },

            { "foo.bar.1",      null },

            { "foo.bar.1gus",   null },

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

        };

    }

    // requires

    private Requires requires(Set<Modifier> mods, String mn) {

        return requires(mods, mn, null);

    }

    private Requires requires(Set<Modifier> mods, String mn, Version v) {

        Builder builder = ModuleDescriptor.newModule("m");

        if (v == null) {

            builder.requires(mods, mn);

        } else {

            builder.requires(mods, mn, v);

        }

        Set<Requires> requires = builder.build().requires();

        assertTrue(requires.size() == 2);

        Iterator<Requires> iterator = requires.iterator();

        Requires r = iterator.next();

        if (r.name().equals("java.base")) {

            r = iterator.next();

        } else {

            Requires other = iterator.next();

            assertEquals(other.name(), "java.base");

        }

        return r;

    }

    private Requires requires(String mn) {

        return requires(Collections.emptySet(), mn);

    }

    public void testRequiresWithRequires() {

        Requires r1 = requires("foo");

        ModuleDescriptor descriptor = ModuleDescriptor.newModule("m").requires(r1).build();

        Requires r2 = descriptor.requires().iterator().next();

        assertEquals(r1, r2);

    }

    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");

        assertFalse(r.compiledVersion().isPresent());

    }

    public void testRequiresWithOneModifier() {

        Requires r = requires(EnumSet.of(TRANSITIVE), "foo");

        assertEquals(r, r);

        assertTrue(r.compareTo(r) == 0);

        assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE));

        assertEquals(r.name(), "foo");

        assertFalse(r.compiledVersion().isPresent());

    }

    public void testRequiresWithTwoModifiers() {

        Requires r = requires(EnumSet.of(TRANSITIVE, SYNTHETIC), "foo");

        assertEquals(r, r);

        assertTrue(r.compareTo(r) == 0);

        assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, SYNTHETIC));

        assertEquals(r.name(), "foo");

        assertFalse(r.compiledVersion().isPresent());

    }

    public void testRequiresWithAllModifiers() {

        Requires r = requires(EnumSet.allOf(Modifier.class), "foo");

        assertEquals(r, r);

        assertTrue(r.compareTo(r) == 0);

        assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, STATIC, SYNTHETIC, MANDATED));

        assertEquals(r.name(), "foo");

        assertFalse(r.compiledVersion().isPresent());

    }

    public void testRequiresWithCompiledVersion() {

        Version v = Version.parse("1.0");

        Requires r = requires(Set.of(), "foo", v);

        assertEquals(r, r);

        assertTrue(r.compareTo(r) == 0);

        assertEquals(r.modifiers(), Set.of());

        assertEquals(r.name(), "foo");

        assertTrue(r.compiledVersion().isPresent());

        assertEquals(r.compiledVersion().get().toString(), "1.0");

    }

    @Test(expectedExceptions = IllegalStateException.class)

    public void testRequiresWithDuplicatesRequires() {

        Requires r = requires("foo");

        ModuleDescriptor.newModule("m").requires(r).requires(r);

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testRequiresSelfWithRequires() {

        Requires r = requires("foo");

        ModuleDescriptor.newModule("foo").requires(r);

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testRequiresSelfWithNoModifier() {

        ModuleDescriptor.newModule("m").requires("m");

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testRequiresSelfWithOneModifier() {

        ModuleDescriptor.newModule("m").requires(Set.of(TRANSITIVE), "m");

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testRequiresSelfWithAllModifiers() {

        ModuleDescriptor.newModule("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() {

        ModuleDescriptor.newModule("m").requires((Requires) null);

    }

    @Test(expectedExceptions = NullPointerException.class)

    public void testRequiresWithNullModifiers() {

        ModuleDescriptor.newModule("m").requires(null, "foo");

    }

    @Test(expectedExceptions = NullPointerException.class)

    public void testRequiresWithNullVersion() {

        ModuleDescriptor.newModule("m").requires(Set.of(), "foo", 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 testRequiresCompareWithDifferentModifiers() {

        Requires r1 = requires(EnumSet.of(TRANSITIVE), "foo");

        Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");

        int n = Integer.compare(1 << TRANSITIVE.ordinal(), 1 << SYNTHETIC.ordinal());

        assertTrue(r1.compareTo(r2) == n);

        assertTrue(r2.compareTo(r1) == -n);

    }

    public void testRequiresCompareWithSameModifiers() {

        Requires r1 = requires(EnumSet.of(SYNTHETIC), "foo");

        Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");

        assertTrue(r1.compareTo(r2) == 0);

        assertTrue(r2.compareTo(r1) == 0);

    }

    public void testRequiresCompareWithSameCompiledVersion() {

        Requires r1 = requires(Set.of(), "foo", Version.parse("2.0"));

        Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));

        assertTrue(r1.compareTo(r2) == 0);

        assertTrue(r2.compareTo(r1) == 0);

    }

    public void testRequiresCompareWithDifferentCompiledVersion() {

        Requires r1 = requires(Set.of(), "foo", Version.parse("1.0"));

        Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));

        assertTrue(r1.compareTo(r2) < 0);

        assertTrue(r2.compareTo(r1) > 0);

    }

    public void testRequiresEqualsAndHashCode() {

        Requires r1 = requires("foo");

        Requires r2 = requires("foo");

        assertEquals(r1, r2);

        assertTrue(r1.hashCode() == r2.hashCode());

        r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");

        r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");

        assertEquals(r1, r2);

        assertTrue(r1.hashCode() == r2.hashCode());

        r1 = requires("foo");

        r2 = requires("bar");

        assertNotEquals(r1, r2);

        r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");

        r2 = requires(Set.of(), "foo");

        assertNotEquals(r1, r2);

        Version v1 = Version.parse("1.0");

        r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);

        r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);

        assertEquals(r1, r2);

        assertTrue(r1.hashCode() == r2.hashCode());

        Version v2 = Version.parse("2.0");

        r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);

        r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v2);

        assertNotEquals(r1, r2);

    }

    public void testRequiresToString() {

        Requires r = requires(EnumSet.noneOf(Modifier.class), "foo");

        assertTrue(r.toString().contains("foo"));

    }

    // exports

    private Exports exports(Set<Exports.Modifier> mods, String pn) {

        return ModuleDescriptor.newModule("foo")

            .exports(mods, pn)

            .build()

            .exports()

            .iterator()

            .next();

    }

    private Exports exports(String pn) {

        return exports(Set.of(), pn);

    }

    private Exports exports(Set<Exports.Modifier> mods, String pn, String target) {

        return ModuleDescriptor.newModule("foo")

            .exports(mods, pn, Set.of(target))

            .build()

            .exports()

            .iterator()

            .next();

    }

    private Exports exports(String pn, String target) {

        return exports(Set.of(), pn, target);

    }

    public void testExportsExports() {

        Exports e1 = exports("p");

        ModuleDescriptor descriptor = ModuleDescriptor.newModule("m").exports(e1).build();

        Exports e2 = descriptor.exports().iterator().next();

        assertEquals(e1, e2);

    }

    public void testExportsToAll() {

        Exports e = exports("p");

        assertEquals(e, e);

        assertTrue(e.modifiers().isEmpty());

        assertEquals(e.source(), "p");

        assertFalse(e.isQualified());

        assertTrue(e.targets().isEmpty());

    }

    public void testExportsToTarget() {

        Exports e = exports("p", "bar");

        assertEquals(e, e);

        assertTrue(e.modifiers().isEmpty());

        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

            = ModuleDescriptor.newModule("foo")

                .exports("p", targets)

                .build()

                .exports()

                .iterator()

                .next();

        assertEquals(e, e);

        assertTrue(e.modifiers().isEmpty());

        assertEquals(e.source(), "p");

        assertTrue(e.isQualified());

        assertTrue(e.targets().size() == 2);

        assertTrue(e.targets().contains("bar"));

        assertTrue(e.targets().contains("gus"));

    }

    public void testExportsToAllWithModifier() {

        Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");

        assertEquals(e, e);

        assertTrue(e.modifiers().size() == 1);

        assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));

        assertEquals(e.source(), "p");

        assertFalse(e.isQualified());

        assertTrue(e.targets().isEmpty());

    }

    public void testExportsToTargetWithModifier() {

        Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p", "bar");

        assertEquals(e, e);

        assertTrue(e.modifiers().size() == 1);

        assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));

        assertEquals(e.source(), "p");

        assertTrue(e.isQualified());

        assertTrue(e.targets().size() == 1);

        assertTrue(e.targets().contains("bar"));

    }

    @Test(expectedExceptions = IllegalStateException.class)

    public void testExportsWithDuplicate1() {

        Exports e = exports("p");

        ModuleDescriptor.newModule("foo").exports(e).exports(e);

    }

    @Test(expectedExceptions = IllegalStateException.class)

    public void testExportsWithDuplicate2() {

        ModuleDescriptor.newModule("foo").exports("p").exports("p");

    }

    @Test(expectedExceptions = IllegalArgumentException.class )

    public void testExportsWithEmptySet() {

        ModuleDescriptor.newModule("foo").exports("p", Collections.emptySet());

    }

    @Test(dataProvider = "invalidjavaidentifiers",

          expectedExceptions = IllegalArgumentException.class )

    public void testExportsWithBadName(String pn, String ignore) {

        ModuleDescriptor.newModule("foo").exports(pn);

    }

    @Test(expectedExceptions = NullPointerException.class )

    public void testExportsWithNullExports() {

        ModuleDescriptor.newModule("foo").exports((Exports) null);

    }

    @Test(expectedExceptions = NullPointerException.class )

    public void testExportsWithNullTargets() {

        ModuleDescriptor.newModule("foo").exports("p", (Set<String>) null);

    }

    public void testExportsCompare() {

        Exports e1 = exports("p");

        Exports e2 = exports("p");

        assertEquals(e1, e2);

        assertTrue(e1.hashCode() == e2.hashCode());

        assertTrue(e1.compareTo(e2) == 0);

        assertTrue(e2.compareTo(e1) == 0);

    }

    public void testExportsCompareWithSameModifiers() {

        Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");

        Exports e2 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");

        assertEquals(e1, e2);

        assertTrue(e1.hashCode() == e2.hashCode());

        assertTrue(e1.compareTo(e2) == 0);

        assertTrue(e2.compareTo(e1) == 0);

    }

    public void testExportsCompareWithDifferentModifiers() {

        Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");

        Exports e2 = exports("p");

        assertNotEquals(e1, e2);

        assertTrue(e1.compareTo(e2) == 1);

        assertTrue(e2.compareTo(e1) == -1);

    }

    public void testExportsCompareWithSameTargets() {

        Exports e1 = exports("p", "x");

        Exports e2 = exports("p", "x");

        assertEquals(e1, e2);

        assertTrue(e1.hashCode() == e2.hashCode());

        assertTrue(e1.compareTo(e2) == 0);

        assertTrue(e2.compareTo(e1) == 0);

    }

    public void testExportsCompareWithDifferentTargets() {

        Exports e1 = exports("p", "y");

        Exports e2 = exports("p", "x");

        assertNotEquals(e1, e2);

        assertTrue(e1.compareTo(e2) == 1);

        assertTrue(e2.compareTo(e1) == -1);

    }

    public void testExportsToString() {

        String s = ModuleDescriptor.newModule("foo")

            .exports("p1", Set.of("bar"))

            .build()

            .exports()

            .iterator()

            .next()

            .toString();

        assertTrue(s.contains("p1"));

        assertTrue(s.contains("bar"));

    }

    // opens

    private Opens opens(Set<Opens.Modifier> mods, String pn) {

        return ModuleDescriptor.newModule("foo")

                .opens(mods, pn)

                .build()

                .opens()

                .iterator()

                .next();

    }

    private Opens opens(String pn) {

        return opens(Set.of(), pn);

    }

    private Opens opens(Set<Opens.Modifier> mods, String pn, String target) {

        return ModuleDescriptor.newModule("foo")

                .opens(mods, pn, Set.of(target))

                .build()

                .opens()

                .iterator()