test/jdk/java/util/ServiceLoader/ModulesTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2016, 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.scripting
  * @library modules /lib/testlibrary
  * @build bananascript/*
  * @build JarUtils
  * @compile classpath/pearscript/org/pear/PearScriptEngineFactory.java
  *          classpath/pearscript/org/pear/PearScript.java
  * @run testng/othervm ModulesTest
  * @summary Basic test for ServiceLoader with a provider deployed as a module.
  */

 import java.io.File;
 import java.lang.module.Configuration;
 import java.lang.module.ModuleFinder;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.script.ScriptEngineFactory;

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

 /**
  * Basic test for ServiceLoader. The test make use of two service providers:
  * 1. BananaScriptEngine - a ScriptEngineFactory deployed as a module on the
  *    module path. It implementations a singleton via the public static
  *    provider method.
  * 2. PearScriptEngine - a ScriptEngineFactory deployed on the class path
  *    with a service configuration file.
  */

 public class ModulesTest {

     // Copy the services configuration file for "pearscript" into place.
     @BeforeTest
     public void setup() throws Exception {
         Path src = Paths.get(System.getProperty("test.src"));
         Path classes = Paths.get(System.getProperty("test.classes"));
         String st = ScriptEngineFactory.class.getName();
         Path config = Paths.get("META-INF", "services", st);
         Path source = src.resolve("classpath").resolve("pearscript").resolve(config);
         Path target = classes.resolve(config);
         Files.createDirectories(target.getParent());
         Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
     }

     /**
      * Basic test of iterator() to ensure that providers located as modules
      * and on the class path are found.
      */
     @Test
     public void testIterator() {
         ServiceLoader<ScriptEngineFactory> loader
             = ServiceLoader.load(ScriptEngineFactory.class);
         Set<String> names = collectAll(loader)
                 .stream()
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertTrue(names.contains("BananaScriptEngine"));
         assertTrue(names.contains("PearScriptEngine"));
     }

     /**
      * Basic test of iterator() to test iteration order. Providers deployed
      * as named modules should be found before providers deployed on the class
      * path.
      */
     @Test
     public void testIteratorOrder() {
         ServiceLoader<ScriptEngineFactory> loader
             = ServiceLoader.load(ScriptEngineFactory.class);
         boolean foundUnnamed = false;
         for (ScriptEngineFactory factory : collectAll(loader)) {
             if (factory.getClass().getModule().isNamed()) {
                 if (foundUnnamed) {
                     assertTrue(false, "Named module element after unnamed");
                 }
             } else {
                 foundUnnamed = true;
             }
         }
     }

     /**
      * Basic test of Provider::type
      */
     @Test
     public void testProviderType() {
         Set<String> types = ServiceLoader.load(ScriptEngineFactory.class)
                 .stream()
                 .map(Provider::type)
                 .map(Class::getName)
                 .collect(Collectors.toSet());
         assertTrue(types.contains("org.banana.BananaScriptEngineFactory"));
         assertTrue(types.contains("org.pear.PearScriptEngineFactory"));
     }

     /**
      * Basic test of Provider::get
      */
     @Test
     public void testProviderGet() {
         Set<String> names = ServiceLoader.load(ScriptEngineFactory.class)
                 .stream()
                 .map(Provider::get)
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertTrue(names.contains("BananaScriptEngine"));
         assertTrue(names.contains("PearScriptEngine"));
     }

     /**
      * Basic test of the public static provider method. BananaScriptEngine
      * defines a provider method that returns the same instance.
      */
     @Test
     public void testSingleton() {
         Optional<Provider<ScriptEngineFactory>> oprovider
             = ServiceLoader.load(ScriptEngineFactory.class)
                 .stream()
                 .filter(p -> p.type().getName().equals("org.banana.BananaScriptEngineFactory"))
                 .findFirst();
         assertTrue(oprovider.isPresent());
         Provider<ScriptEngineFactory> provider = oprovider.get();

         // invoke Provider::get twice
         ScriptEngineFactory factory1 = provider.get();
         ScriptEngineFactory factory2 = provider.get();
         assertTrue(factory1 == factory2);
     }

     /**
      * Basic test of stream() to ensure that elements for providers in named
      * modules come before elements for providers in unnamed modules.
      */
     @Test
     public void testStreamOrder() {
         List<Class<?>> types = ServiceLoader.load(ScriptEngineFactory.class)
                 .stream()
                 .map(Provider::type)
                 .collect(Collectors.toList());

         boolean foundUnnamed = false;
         for (Class<?> factoryClass : types) {
             if (factoryClass.getModule().isNamed()) {
                 if (foundUnnamed) {
                     assertTrue(false, "Named module element after unnamed");
                 }
             } else {
                 foundUnnamed = true;
             }
         }
     }

     /**
      * Basic test of ServiceLoader.findFirst()
      */
     @Test
     public void testFindFirst() {
         Optional<ScriptEngineFactory> ofactory
             = ServiceLoader.load(ScriptEngineFactory.class).findFirst();
         assertTrue(ofactory.isPresent());
         ScriptEngineFactory factory = ofactory.get();
         assertTrue(factory.getClass().getModule().isNamed());

         class S { }
         assertFalse(ServiceLoader.load(S.class).findFirst().isPresent());
     }

     /**
      * Basic test ServiceLoader.load specifying the platform class loader.
      * The providers on the module path and class path should not be located.
      */
     @Test
     public void testWithPlatformClassLoader() {
         ClassLoader pcl = ClassLoader.getPlatformClassLoader();

         // iterator
         ServiceLoader<ScriptEngineFactory> loader
             = ServiceLoader.load(ScriptEngineFactory.class, pcl);
         Set<String> names = collectAll(loader)
                 .stream()
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertFalse(names.contains("BananaScriptEngine"));
         assertFalse(names.contains("PearScriptEngine"));

         // stream
         names = ServiceLoader.load(ScriptEngineFactory.class, pcl)
                 .stream()
                 .map(Provider::get)
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertFalse(names.contains("BananaScriptEngine"));
         assertFalse(names.contains("PearScriptEngine"));
     }

     /**
      * Basic test of ServiceLoader.load where the service provider module is an
      * automatic module.
      */
     @Test
     public void testWithAutomaticModule() throws Exception {
         Path here = Paths.get("");
         Path jar = Files.createTempDirectory(here, "lib").resolve("pearscript.jar");
         Path classes = Paths.get(System.getProperty("test.classes"));

         JarUtils.createJarFile(jar, classes, "META-INF", "org");

         ModuleFinder finder = ModuleFinder.of(jar);
         ModuleLayer bootLayer = ModuleLayer.boot();
         Configuration parent = bootLayer.configuration();
         Configuration cf = parent.resolveAndBind(finder, ModuleFinder.of(), Set.of());
         assertTrue(cf.modules().size() == 1);

         ClassLoader scl = ClassLoader.getSystemClassLoader();
         ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
         assertTrue(layer.modules().size() == 1);

         ClassLoader loader = layer.findLoader("pearscript");
         ScriptEngineFactory factory;

         // load using the class loader as context
         factory = ServiceLoader.load(ScriptEngineFactory.class, loader)
                 .findFirst()
                 .orElse(null);
         assertNotNull(factory);
         assertTrue(factory.getClass().getClassLoader() == loader);

         // load using the layer as context
         factory = ServiceLoader.load(layer, ScriptEngineFactory.class)
                 .findFirst()
                 .orElse(null);
         assertNotNull(factory);
         assertTrue(factory.getClass().getClassLoader() == loader);
     }

     /**
      * Basic test of ServiceLoader.load, using the class loader for
      * a module in a custom layer as the context.
      */
     @Test
     public void testWithCustomLayer1() {
         ModuleLayer layer = createCustomLayer("bananascript");

         ClassLoader loader = layer.findLoader("bananascript");
         List<ScriptEngineFactory> providers
             = collectAll(ServiceLoader.load(ScriptEngineFactory.class, loader));

         // should have at least 2 x bananascript + pearscript
         assertTrue(providers.size() >= 3);

         // first element should be the provider in the custom layer
         ScriptEngineFactory factory = providers.get(0);
         assertTrue(factory.getClass().getClassLoader() == loader);
         assertTrue(factory.getClass().getModule().getLayer() == layer);
         assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

         // remainder should be the boot layer
         providers.remove(0);
         Set<String> names = providers.stream()
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertTrue(names.contains("BananaScriptEngine"));
         assertTrue(names.contains("PearScriptEngine"));
     }

     /**
      * Basic test of ServiceLoader.load using a custom Layer as the context.
      */
     @Test
     public void testWithCustomLayer2() {
         ModuleLayer layer = createCustomLayer("bananascript");

         List<ScriptEngineFactory> factories
             = collectAll(ServiceLoader.load(layer, ScriptEngineFactory.class));

         // should have at least 2 x bananascript
         assertTrue(factories.size() >= 2);

         // first element should be the provider in the custom layer
         ScriptEngineFactory factory = factories.get(0);
         assertTrue(factory.getClass().getModule().getLayer() == layer);
         assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

         // remainder should be the boot layer
         factories.remove(0);
         Set<String> names = factories.stream()
                 .map(ScriptEngineFactory::getEngineName)
                 .collect(Collectors.toSet());
         assertTrue(names.contains("BananaScriptEngine"));
         assertFalse(names.contains("PearScriptEngine"));
     }

     /**
      * Basic test of ServiceLoader.load with a tree of layers.
      *
      * Test scenario:
      * - boot layer contains "bananascript", maybe other script engines
      * - layer1, with boot layer as parent, contains "bananascript"
      * - layer2, with boot layer as parent, contains "bananascript"
      * - layer3, with layer1 ad layer as parents, contains "bananascript"
      *
      * ServiceLoader should locate all 4 script engine factories in DFS order.
      */
     @Test
     public void testWithCustomLayer3() {
         ModuleLayer bootLayer = ModuleLayer.boot();
         Configuration cf0 = bootLayer.configuration();

         // boot layer should contain "bananascript"
         List<ScriptEngineFactory> factories
             = collectAll(ServiceLoader.load(bootLayer, ScriptEngineFactory.class));
         int countInBootLayer = factories.size();
         assertTrue(countInBootLayer >= 1);
         assertTrue(factories.stream()
                 .map(p -> p.getEngineName())
                 .filter("BananaScriptEngine"::equals)
                 .findAny()
                 .isPresent());

         ClassLoader scl = ClassLoader.getSystemClassLoader();
         ModuleFinder finder = ModuleFinder.of(testModulePath());

         // layer1
         Configuration cf1 = cf0.resolveAndBind(finder, ModuleFinder.of(), Set.of());
         ModuleLayer layer1 = bootLayer.defineModulesWithOneLoader(cf1, scl);
         assertTrue(layer1.modules().size() == 1);

         // layer2
         Configuration cf2 = cf0.resolveAndBind(finder, ModuleFinder.of(), Set.of());
         ModuleLayer layer2 = bootLayer.defineModulesWithOneLoader(cf2, scl);
         assertTrue(layer2.modules().size() == 1);

         // layer3 with layer1 and layer2 as parents
         Configuration cf3 = Configuration.resolveAndBind(finder,
                 List.of(cf1, cf2),
                 ModuleFinder.of(),
                 Set.of());
         ModuleLayer layer3
             = ModuleLayer.defineModulesWithOneLoader(cf3, List.of(layer1, layer2), scl).layer();
         assertTrue(layer3.modules().size() == 1);


         // class loaders
         ClassLoader loader1 = layer1.findLoader("bananascript");
         ClassLoader loader2 = layer2.findLoader("bananascript");
         ClassLoader loader3 = layer3.findLoader("bananascript");
         assertTrue(loader1 != loader2);
         assertTrue(loader1 != loader3);
         assertTrue(loader2 != loader3);

         // load all factories with layer3 as the context
         factories = collectAll(ServiceLoader.load(layer3, ScriptEngineFactory.class));
         int count = factories.size();
         assertTrue(count == countInBootLayer + 3);

         // the ordering should be layer3, layer1, boot layer, layer2

         ScriptEngineFactory factory = factories.get(0);
         assertTrue(factory.getClass().getModule().getLayer() == layer3);
         assertTrue(factory.getClass().getClassLoader() == loader3);
         assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

         factory = factories.get(1);
         assertTrue(factory.getClass().getModule().getLayer() == layer1);
         assertTrue(factory.getClass().getClassLoader() == loader1);
         assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

         // boot layer "bananascript" and maybe other factories
         int last = count -1;
         boolean found = false;
         for (int i=2; i<last; i++) {
             factory = factories.get(i);
             assertTrue(factory.getClass().getModule().getLayer() == bootLayer);
             if (factory.getEngineName().equals("BananaScriptEngine")) {
                 assertFalse(found);
                 found = true;
             }
         }
         assertTrue(found);

         factory = factories.get(last);
         assertTrue(factory.getClass().getModule().getLayer() == layer2);
         assertTrue(factory.getClass().getClassLoader() == loader2);
         assertTrue(factory.getEngineName().equals("BananaScriptEngine"));
     }


     // -- nulls --

     @Test(expectedExceptions = { NullPointerException.class })
     public void testLoadNull1() {
         ServiceLoader.load(null);
     }

     @Test(expectedExceptions = { NullPointerException.class })
     public void testLoadNull2() {
         ServiceLoader.load((Class<?>) null, ClassLoader.getSystemClassLoader());
     }

     @Test(expectedExceptions = { NullPointerException.class })
     public void testLoadNull3() {
         class S { }
         ServiceLoader.load((ModuleLayer) null, S.class);
     }

     @Test(expectedExceptions = { NullPointerException.class })
     public void testLoadNull4() {
         ServiceLoader.load(ModuleLayer.empty(), null);
     }

     @Test(expectedExceptions = { NullPointerException.class })
     public void testLoadNull5() {
         ServiceLoader.loadInstalled(null);
     }

     /**
      * Create a custom layer by resolving the given module names. The modules
      * are located on the test module path ({@code ${test.module.path}}).
      */
     private ModuleLayer createCustomLayer(String... modules) {
         ModuleFinder finder = ModuleFinder.of(testModulePath());
         Set<String> roots = new HashSet<>();
         Collections.addAll(roots, modules);
         ModuleLayer bootLayer = ModuleLayer.boot();
         Configuration parent = bootLayer.configuration();
         Configuration cf = parent.resolve(finder, ModuleFinder.of(), roots);
         ClassLoader scl = ClassLoader.getSystemClassLoader();
         ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
         assertTrue(layer.modules().size() == 1);
         return layer;
     }

     private Path[] testModulePath() {
         String mp = System.getProperty("test.module.path");
         return Stream.of(mp.split(File.pathSeparator))
                 .map(Paths::get)
                 .toArray(Path[]::new);
     }

     private <E> List<E> collectAll(ServiceLoader<E> loader) {
         List<E> list = new ArrayList<>();
         Iterator<E> iterator = loader.iterator();
         while (iterator.hasNext()) {
             list.add(iterator.next());
         }
         return list;
     }
 }
	/*
	* Copyright (c) 2016, 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.scripting
	* @library modules /lib/testlibrary
	* @build bananascript/*
	* @build JarUtils
	* @compile classpath/pearscript/org/pear/PearScriptEngineFactory.java
	* classpath/pearscript/org/pear/PearScript.java
	* @run testng/othervm ModulesTest
	* @summary Basic test for ServiceLoader with a provider deployed as a module.
	*/

	import java.io.File;
	import java.lang.module.Configuration;
	import java.lang.module.ModuleFinder;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.StandardCopyOption;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Optional;
	import java.util.ServiceLoader;
	import java.util.ServiceLoader.Provider;
	import java.util.Set;
	import java.util.stream.Collectors;
	import java.util.stream.Stream;
	import javax.script.ScriptEngineFactory;

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

	/**
	* Basic test for ServiceLoader. The test make use of two service providers:
	* 1. BananaScriptEngine - a ScriptEngineFactory deployed as a module on the
	* module path. It implementations a singleton via the public static
	* provider method.
	* 2. PearScriptEngine - a ScriptEngineFactory deployed on the class path
	* with a service configuration file.
	*/

	public class ModulesTest {

	// Copy the services configuration file for "pearscript" into place.
	@BeforeTest
	public void setup() throws Exception {
	Path src = Paths.get(System.getProperty("test.src"));
	Path classes = Paths.get(System.getProperty("test.classes"));
	String st = ScriptEngineFactory.class.getName();
	Path config = Paths.get("META-INF", "services", st);
	Path source = src.resolve("classpath").resolve("pearscript").resolve(config);
	Path target = classes.resolve(config);
	Files.createDirectories(target.getParent());
	Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
	}

	/**
	* Basic test of iterator() to ensure that providers located as modules
	* and on the class path are found.
	*/
	@Test
	public void testIterator() {
	ServiceLoader<ScriptEngineFactory> loader
	= ServiceLoader.load(ScriptEngineFactory.class);
	Set<String> names = collectAll(loader)
	.stream()
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertTrue(names.contains("BananaScriptEngine"));
	assertTrue(names.contains("PearScriptEngine"));
	}

	/**
	* Basic test of iterator() to test iteration order. Providers deployed
	* as named modules should be found before providers deployed on the class
	* path.
	*/
	@Test
	public void testIteratorOrder() {
	ServiceLoader<ScriptEngineFactory> loader
	= ServiceLoader.load(ScriptEngineFactory.class);
	boolean foundUnnamed = false;
	for (ScriptEngineFactory factory : collectAll(loader)) {
	if (factory.getClass().getModule().isNamed()) {
	if (foundUnnamed) {
	assertTrue(false, "Named module element after unnamed");
	}
	} else {
	foundUnnamed = true;
	}
	}
	}

	/**
	* Basic test of Provider::type
	*/
	@Test
	public void testProviderType() {
	Set<String> types = ServiceLoader.load(ScriptEngineFactory.class)
	.stream()
	.map(Provider::type)
	.map(Class::getName)
	.collect(Collectors.toSet());
	assertTrue(types.contains("org.banana.BananaScriptEngineFactory"));
	assertTrue(types.contains("org.pear.PearScriptEngineFactory"));
	}

	/**
	* Basic test of Provider::get
	*/
	@Test
	public void testProviderGet() {
	Set<String> names = ServiceLoader.load(ScriptEngineFactory.class)
	.stream()
	.map(Provider::get)
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertTrue(names.contains("BananaScriptEngine"));
	assertTrue(names.contains("PearScriptEngine"));
	}

	/**
	* Basic test of the public static provider method. BananaScriptEngine
	* defines a provider method that returns the same instance.
	*/
	@Test
	public void testSingleton() {
	Optional<Provider<ScriptEngineFactory>> oprovider
	= ServiceLoader.load(ScriptEngineFactory.class)
	.stream()
	.filter(p -> p.type().getName().equals("org.banana.BananaScriptEngineFactory"))
	.findFirst();
	assertTrue(oprovider.isPresent());
	Provider<ScriptEngineFactory> provider = oprovider.get();

	// invoke Provider::get twice
	ScriptEngineFactory factory1 = provider.get();
	ScriptEngineFactory factory2 = provider.get();
	assertTrue(factory1 == factory2);
	}

	/**
	* Basic test of stream() to ensure that elements for providers in named
	* modules come before elements for providers in unnamed modules.
	*/
	@Test
	public void testStreamOrder() {
	List<Class<?>> types = ServiceLoader.load(ScriptEngineFactory.class)
	.stream()
	.map(Provider::type)
	.collect(Collectors.toList());

	boolean foundUnnamed = false;
	for (Class<?> factoryClass : types) {
	if (factoryClass.getModule().isNamed()) {
	if (foundUnnamed) {
	assertTrue(false, "Named module element after unnamed");
	}
	} else {
	foundUnnamed = true;
	}
	}
	}

	/**
	* Basic test of ServiceLoader.findFirst()
	*/
	@Test
	public void testFindFirst() {
	Optional<ScriptEngineFactory> ofactory
	= ServiceLoader.load(ScriptEngineFactory.class).findFirst();
	assertTrue(ofactory.isPresent());
	ScriptEngineFactory factory = ofactory.get();
	assertTrue(factory.getClass().getModule().isNamed());

	class S { }
	assertFalse(ServiceLoader.load(S.class).findFirst().isPresent());
	}

	/**
	* Basic test ServiceLoader.load specifying the platform class loader.
	* The providers on the module path and class path should not be located.
	*/
	@Test
	public void testWithPlatformClassLoader() {
	ClassLoader pcl = ClassLoader.getPlatformClassLoader();

	// iterator
	ServiceLoader<ScriptEngineFactory> loader
	= ServiceLoader.load(ScriptEngineFactory.class, pcl);
	Set<String> names = collectAll(loader)
	.stream()
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertFalse(names.contains("BananaScriptEngine"));
	assertFalse(names.contains("PearScriptEngine"));

	// stream
	names = ServiceLoader.load(ScriptEngineFactory.class, pcl)
	.stream()
	.map(Provider::get)
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertFalse(names.contains("BananaScriptEngine"));
	assertFalse(names.contains("PearScriptEngine"));
	}

	/**
	* Basic test of ServiceLoader.load where the service provider module is an
	* automatic module.
	*/
	@Test
	public void testWithAutomaticModule() throws Exception {
	Path here = Paths.get("");
	Path jar = Files.createTempDirectory(here, "lib").resolve("pearscript.jar");
	Path classes = Paths.get(System.getProperty("test.classes"));

	JarUtils.createJarFile(jar, classes, "META-INF", "org");

	ModuleFinder finder = ModuleFinder.of(jar);
	ModuleLayer bootLayer = ModuleLayer.boot();
	Configuration parent = bootLayer.configuration();
	Configuration cf = parent.resolveAndBind(finder, ModuleFinder.of(), Set.of());
	assertTrue(cf.modules().size() == 1);

	ClassLoader scl = ClassLoader.getSystemClassLoader();
	ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
	assertTrue(layer.modules().size() == 1);

	ClassLoader loader = layer.findLoader("pearscript");
	ScriptEngineFactory factory;

	// load using the class loader as context
	factory = ServiceLoader.load(ScriptEngineFactory.class, loader)
	.findFirst()
	.orElse(null);
	assertNotNull(factory);
	assertTrue(factory.getClass().getClassLoader() == loader);

	// load using the layer as context
	factory = ServiceLoader.load(layer, ScriptEngineFactory.class)
	.findFirst()
	.orElse(null);
	assertNotNull(factory);
	assertTrue(factory.getClass().getClassLoader() == loader);
	}

	/**
	* Basic test of ServiceLoader.load, using the class loader for
	* a module in a custom layer as the context.
	*/
	@Test
	public void testWithCustomLayer1() {
	ModuleLayer layer = createCustomLayer("bananascript");

	ClassLoader loader = layer.findLoader("bananascript");
	List<ScriptEngineFactory> providers
	= collectAll(ServiceLoader.load(ScriptEngineFactory.class, loader));

	// should have at least 2 x bananascript + pearscript
	assertTrue(providers.size() >= 3);

	// first element should be the provider in the custom layer
	ScriptEngineFactory factory = providers.get(0);
	assertTrue(factory.getClass().getClassLoader() == loader);
	assertTrue(factory.getClass().getModule().getLayer() == layer);
	assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

	// remainder should be the boot layer
	providers.remove(0);
	Set<String> names = providers.stream()
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertTrue(names.contains("BananaScriptEngine"));
	assertTrue(names.contains("PearScriptEngine"));
	}

	/**
	* Basic test of ServiceLoader.load using a custom Layer as the context.
	*/
	@Test
	public void testWithCustomLayer2() {
	ModuleLayer layer = createCustomLayer("bananascript");

	List<ScriptEngineFactory> factories
	= collectAll(ServiceLoader.load(layer, ScriptEngineFactory.class));

	// should have at least 2 x bananascript
	assertTrue(factories.size() >= 2);

	// first element should be the provider in the custom layer
	ScriptEngineFactory factory = factories.get(0);
	assertTrue(factory.getClass().getModule().getLayer() == layer);
	assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

	// remainder should be the boot layer
	factories.remove(0);
	Set<String> names = factories.stream()
	.map(ScriptEngineFactory::getEngineName)
	.collect(Collectors.toSet());
	assertTrue(names.contains("BananaScriptEngine"));
	assertFalse(names.contains("PearScriptEngine"));
	}

	/**
	* Basic test of ServiceLoader.load with a tree of layers.
	*
	* Test scenario:
	* - boot layer contains "bananascript", maybe other script engines
	* - layer1, with boot layer as parent, contains "bananascript"
	* - layer2, with boot layer as parent, contains "bananascript"
	* - layer3, with layer1 ad layer as parents, contains "bananascript"
	*
	* ServiceLoader should locate all 4 script engine factories in DFS order.
	*/
	@Test
	public void testWithCustomLayer3() {
	ModuleLayer bootLayer = ModuleLayer.boot();
	Configuration cf0 = bootLayer.configuration();

	// boot layer should contain "bananascript"
	List<ScriptEngineFactory> factories
	= collectAll(ServiceLoader.load(bootLayer, ScriptEngineFactory.class));
	int countInBootLayer = factories.size();
	assertTrue(countInBootLayer >= 1);
	assertTrue(factories.stream()
	.map(p -> p.getEngineName())
	.filter("BananaScriptEngine"::equals)
	.findAny()
	.isPresent());

	ClassLoader scl = ClassLoader.getSystemClassLoader();
	ModuleFinder finder = ModuleFinder.of(testModulePath());

	// layer1
	Configuration cf1 = cf0.resolveAndBind(finder, ModuleFinder.of(), Set.of());
	ModuleLayer layer1 = bootLayer.defineModulesWithOneLoader(cf1, scl);
	assertTrue(layer1.modules().size() == 1);

	// layer2
	Configuration cf2 = cf0.resolveAndBind(finder, ModuleFinder.of(), Set.of());
	ModuleLayer layer2 = bootLayer.defineModulesWithOneLoader(cf2, scl);
	assertTrue(layer2.modules().size() == 1);

	// layer3 with layer1 and layer2 as parents
	Configuration cf3 = Configuration.resolveAndBind(finder,
	List.of(cf1, cf2),
	ModuleFinder.of(),
	Set.of());
	ModuleLayer layer3
	= ModuleLayer.defineModulesWithOneLoader(cf3, List.of(layer1, layer2), scl).layer();
	assertTrue(layer3.modules().size() == 1);


	// class loaders
	ClassLoader loader1 = layer1.findLoader("bananascript");
	ClassLoader loader2 = layer2.findLoader("bananascript");
	ClassLoader loader3 = layer3.findLoader("bananascript");
	assertTrue(loader1 != loader2);
	assertTrue(loader1 != loader3);
	assertTrue(loader2 != loader3);

	// load all factories with layer3 as the context
	factories = collectAll(ServiceLoader.load(layer3, ScriptEngineFactory.class));
	int count = factories.size();
	assertTrue(count == countInBootLayer + 3);

	// the ordering should be layer3, layer1, boot layer, layer2

	ScriptEngineFactory factory = factories.get(0);
	assertTrue(factory.getClass().getModule().getLayer() == layer3);
	assertTrue(factory.getClass().getClassLoader() == loader3);
	assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

	factory = factories.get(1);
	assertTrue(factory.getClass().getModule().getLayer() == layer1);
	assertTrue(factory.getClass().getClassLoader() == loader1);
	assertTrue(factory.getEngineName().equals("BananaScriptEngine"));

	// boot layer "bananascript" and maybe other factories
	int last = count -1;
	boolean found = false;
	for (int i=2; i<last; i++) {
	factory = factories.get(i);
	assertTrue(factory.getClass().getModule().getLayer() == bootLayer);
	if (factory.getEngineName().equals("BananaScriptEngine")) {
	assertFalse(found);
	found = true;
	}
	}
	assertTrue(found);

	factory = factories.get(last);
	assertTrue(factory.getClass().getModule().getLayer() == layer2);
	assertTrue(factory.getClass().getClassLoader() == loader2);
	assertTrue(factory.getEngineName().equals("BananaScriptEngine"));
	}


	// -- nulls --

	@Test(expectedExceptions = { NullPointerException.class })
	public void testLoadNull1() {
	ServiceLoader.load(null);
	}

	@Test(expectedExceptions = { NullPointerException.class })
	public void testLoadNull2() {
	ServiceLoader.load((Class<?>) null, ClassLoader.getSystemClassLoader());
	}

	@Test(expectedExceptions = { NullPointerException.class })
	public void testLoadNull3() {
	class S { }
	ServiceLoader.load((ModuleLayer) null, S.class);
	}

	@Test(expectedExceptions = { NullPointerException.class })
	public void testLoadNull4() {
	ServiceLoader.load(ModuleLayer.empty(), null);
	}

	@Test(expectedExceptions = { NullPointerException.class })
	public void testLoadNull5() {
	ServiceLoader.loadInstalled(null);
	}

	/**
	* Create a custom layer by resolving the given module names. The modules
	* are located on the test module path ({@code ${test.module.path}}).
	*/
	private ModuleLayer createCustomLayer(String... modules) {
	ModuleFinder finder = ModuleFinder.of(testModulePath());
	Set<String> roots = new HashSet<>();
	Collections.addAll(roots, modules);
	ModuleLayer bootLayer = ModuleLayer.boot();
	Configuration parent = bootLayer.configuration();
	Configuration cf = parent.resolve(finder, ModuleFinder.of(), roots);
	ClassLoader scl = ClassLoader.getSystemClassLoader();
	ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
	assertTrue(layer.modules().size() == 1);
	return layer;
	}

	private Path[] testModulePath() {
	String mp = System.getProperty("test.module.path");
	return Stream.of(mp.split(File.pathSeparator))
	.map(Paths::get)
	.toArray(Path[]::new);
	}

	private <E> List<E> collectAll(ServiceLoader<E> loader) {
	List<E> list = new ArrayList<>();
	Iterator<E> iterator = loader.iterator();
	while (iterator.hasNext()) {
	list.add(iterator.next());
	}
	return list;
	}
	}