/*

 * 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

 * @summary Basic test for redefineModule

 *

 * @build java.base/java.lang.TestProvider

 *        java.base/jdk.internal.test.TestProviderImpl1

 *        java.base/jdk.internal.test.TestProviderImpl2

 * @run shell MakeJAR3.sh RedefineModuleAgent

 * @run testng/othervm -javaagent:RedefineModuleAgent.jar RedefineModuleTest

 */

import java.lang.TestProvider;

import java.lang.instrument.Instrumentation;

import java.net.URLStreamHandler;

import java.net.spi.URLStreamHandlerProvider;

import java.nio.file.FileSystems;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.ServiceLoader;

import java.util.Set;

import org.testng.annotations.Test;

import static org.testng.Assert.*;

@Test

public class RedefineModuleTest {

    static void redefineModule(Module module,

                               Set<Module> extraReads,

                               Map<String, Set<Module>> extraExports,

                               Map<String, Set<Module>> extraOpens,

                               Set<Class<?>> extraUses,

                               Map<Class<?>, List<Class<?>>> extraProvides) {

        RedefineModuleAgent.redefineModule(module,

                                           extraReads,

                                           extraExports,

                                           extraOpens,

                                           extraUses,

                                           extraProvides);

    }

    /**

     * Use redefineModule to update java.base to read java.instrument

     */

    public void testAddReads() {

        Module baseModule = Object.class.getModule();

        Module instrumentModule = Instrumentation.class.getModule();

        // pre-conditions

        assertFalse(baseModule.canRead(instrumentModule));

        // update java.base to read java.instrument

        Set<Module> extraReads = Set.of(instrumentModule);

        redefineModule(baseModule, extraReads, Map.of(), Map.of(), Set.of(), Map.of());

        assertTrue(baseModule.canRead(instrumentModule));

    }

    /**

     * Use redefineModule to update java.base to export jdk.internal.misc

     */

    public void testAddExports() {

        Module baseModule = Object.class.getModule();

        Module thisModule = this.getClass().getClassLoader().getUnnamedModule();

        String pkg = "jdk.internal.misc";

        // pre-conditions

        assertFalse(baseModule.isExported(pkg));

        assertFalse(baseModule.isExported(pkg, thisModule));

        // update java.base to export jdk.internal.misc to an unnamed module

        Map<String, Set<Module>> extraExports = Map.of(pkg, Set.of(thisModule));

        redefineModule(baseModule, Set.of(), extraExports, Map.of(), Set.of(), Map.of());

        assertFalse(baseModule.isExported(pkg));

        assertTrue(baseModule.isExported(pkg, thisModule));

        assertFalse(baseModule.isOpen(pkg));

        assertFalse(baseModule.isOpen(pkg, thisModule));

    }

    /**

     * Use redefineModule to update java.base to open jdk.internal.loader

     */

    public void testAddOpens() {

        Module baseModule = Object.class.getModule();

        Module thisModule = this.getClass().getClassLoader().getUnnamedModule();

        String pkg = "jdk.internal.loader";

        // pre-conditions

        assertFalse(baseModule.isOpen(pkg));

        assertFalse(baseModule.isOpen(pkg, thisModule));

        // update java.base to open dk.internal.loader to an unnamed module

        Map<String, Set<Module>> extraExports = Map.of(pkg, Set.of(thisModule));

        redefineModule(baseModule, Set.of(), Map.of(), extraExports, Set.of(), Map.of());

        assertFalse(baseModule.isExported(pkg));

        assertTrue(baseModule.isExported(pkg, thisModule));

        assertFalse(baseModule.isOpen(pkg));

        assertTrue(baseModule.isOpen(pkg, thisModule));

    }

    /**

     * Use redefineModule to update java.base to use TestProvider and

     * provide implementations of TestProvider.

     */

    public void testAddUsesAndProvides() throws Exception {

        Module baseModule = Object.class.getModule();

        Class<TestProvider> service = TestProvider.class;

        // pre-conditions

        assertFalse(baseModule.canUse(service));

        assertTrue(collect(ServiceLoader.load(service)).isEmpty());

        // update java.base to use TestProvider

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(service), Map.of());

        assertTrue(baseModule.canUse(service));

        assertTrue(collect(ServiceLoader.load(service)).isEmpty());

        // update java.base to provide an implementation of TestProvider

        Class<?> type1 = Class.forName("jdk.internal.test.TestProviderImpl1");

        Map<Class<?>, List<Class<?>>> extraProvides = Map.of(service, List.of(type1));

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

        // invoke ServiceLoader from java.base to find providers

        Set<TestProvider> providers = collect(TestProvider.providers());

        assertTrue(providers.size() == 1);

        assertTrue(containsInstanceOf(providers, type1));

        // use ServiceLoader to load implementations visible via TCCL

        providers = collect(ServiceLoader.load(service));

        assertTrue(collect(providers).size() == 1);

        assertTrue(containsInstanceOf(collect(providers), type1));

        // use ServiceLoader to load implementations in the boot layer

        assertTrue(collect(providers).size() == 1);

        assertTrue(containsInstanceOf(collect(providers), type1));

        // update java.base to provide a second implementation of TestProvider

        Class<?> type2 = Class.forName("jdk.internal.test.TestProviderImpl2");

        extraProvides = Map.of(service, List.of(type2));

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

        // invoke ServiceLoader from java.base to find providers

        providers = collect(TestProvider.providers());

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

        assertTrue(containsInstanceOf(providers, type1));

        assertTrue(containsInstanceOf(providers, type2));

        // use ServiceLoader to load implementations visible via TCCL

        providers = collect(ServiceLoader.load(service));

        assertTrue(collect(providers).size() == 2);

        assertTrue(containsInstanceOf(providers, type1));

        assertTrue(containsInstanceOf(providers, type2));

        // use ServiceLoader to load implementations in the boot layer

        assertTrue(collect(providers).size() == 2);

        assertTrue(containsInstanceOf(providers, type1));

        assertTrue(containsInstanceOf(providers, type2));

    }

    private <S> Set<S> collect(Iterable<S> sl) {

        Set<S> providers = new HashSet<>();

        sl.forEach(providers::add);

        return providers;

    }

    private boolean containsInstanceOf(Collection<?> c, Class<?> type) {

        for (Object o : c) {

            if (type.isInstance(o)) return true;

        }

        return false;

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testExportPackageToEmptySet() {

        // attempt to update java.base to export jdk.internal.misc to nobody

        Module baseModule = Object.class.getModule();

        Map<String, Set<Module>> extraExports = Map.of("jdk.internal.misc", Set.of());

        redefineModule(baseModule, Set.of(), extraExports, Map.of(), Set.of(), Map.of());

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testOpenPackageToEmptySet() {

        // attempt to update java.base to open jdk.internal.misc to nobody

        Module baseModule = Object.class.getModule();

        Map<String, Set<Module>> extraOpens = Map.of("jdk.internal.misc", Set.of());

        redefineModule(baseModule, Set.of(), Map.of(), extraOpens, Set.of(), Map.of());

    }

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testProvideServiceWithEmptyList() throws Exception {

        // update java.base to provide an empty list of TestProvider

        Module baseModule = Object.class.getModule();

        Class<?> service = TestProvider.class;

        Map<Class<?>, List<Class<?>>> extraProvides = Map.of(service, List.of());

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

    }

    /**

     * Test redefineClass by attempting to update java.base to export a package

     * that it does not contain.

     */

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testExportPackageNotInModule() {

        Module baseModule = Object.class.getModule();

        String pkg = "jdk.doesnotexist";

        // attempt to update java.base to export jdk.doesnotexist

        Map<String, Set<Module>> extraExports = Map.of(pkg, Set.of());

        redefineModule(baseModule, Set.of(), extraExports, Map.of(), Set.of(), Map.of());

    }

    /**

     * Test redefineClass by attempting to update java.base to provide a service

     * where the service provider class is not in the module.

     */

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testProvideServiceNotInModule() {

        Module baseModule = Object.class.getModule();

        class MyProvider extends URLStreamHandlerProvider {

            @Override

            public URLStreamHandler createURLStreamHandler(String protocol) {

                return null;

            }

        }

        // attempt to update java.base to provide MyProvider

        Map<Class<?>, List<Class<?>>> extraProvides

            = Map.of(URLStreamHandlerProvider.class, List.of(MyProvider.class));

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

    }

    /**

     * Test redefineClass by attempting to update java.base to provide a

     * service where the service provider class is not a sub-type.

     */

    @Test(expectedExceptions = IllegalArgumentException.class)

    public void testProvideServiceNotSubtype() {

        Module baseModule = Object.class.getModule();

        Class<?> service = TestProvider.class;

        Class<?> impl = FileSystems.getDefault().provider().getClass();

        // attempt to update java.base to provide an implementation of TestProvider

        Map<Class<?>, List<Class<?>>> extraProvides = Map.of(service, List.of(impl));

        redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

    }

    /**

     * Test redefineClass with null

     */

    public void testNulls() {

        Module baseModule = Object.class.getModule();

        try {

            redefineModule(null, Set.of(), Map.of(), Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            redefineModule(baseModule, null, Map.of(), Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            redefineModule(baseModule, Set.of(), null, Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            redefineModule(baseModule, Set.of(), Map.of(), null, Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            redefineModule(baseModule, Set.of(), Map.of(), Map.of(), null, Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), null);

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Set<Module> containsNull = new HashSet<>();

            containsNull.add(null);

            redefineModule(baseModule, containsNull, Map.of(), Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Map<String, Set<Module>> extraExports = new HashMap<>();

            extraExports.put(null, Set.of());

            redefineModule(baseModule, Set.of(), extraExports, Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Map<String, Set<Module>> extraExports = new HashMap<>();

            extraExports.put(null, Set.of());

            redefineModule(baseModule, Set.of(), Map.of(), extraExports, Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Set<Module> containsNull = new HashSet<>();

            containsNull.add(null);

            Map<String, Set<Module>> extraExports = Map.of("java.lang", containsNull);

            redefineModule(baseModule, Set.of(), extraExports, Map.of(), Set.of(), Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Set<Class<?>> containsNull = new HashSet<>();

            containsNull.add(null);

            redefineModule(baseModule, Set.of(), Map.of(), Map.of(), containsNull, Map.of());

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            Map<Class<?>, List<Class<?>>> extraProvides = new HashMap<>();

            extraProvides.put(null, List.of());

            redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

            assertTrue(false);

        } catch (NullPointerException e) { }

        try {

            List<Class<?>> containsNull = new ArrayList<>();

            containsNull.add(null);

            Map<Class<?>, List<Class<?>>> extraProvides = Map.of(TestProvider.class, containsNull);

            redefineModule(baseModule, Set.of(), Map.of(), Map.of(), Set.of(), extraProvides);

            assertTrue(false);

        } catch (NullPointerException e) { }

    }

}