*/
    ClassLoaderScope createLockedChild(String id, @Nullable ClassLoaderScopeOrigin origin, ClassPath localClasspath, @Nullable HashCode classpathImplementationHash, @Nullable Function<ClassLoader, ClassLoader> localClassLoaderFactory);

    /**

/**
 * Unit test for {@link FinalizableReferenceQueue}.
 *
 * @author Bob Lee
 */
// - depends on details of GC and classloading
// - .class files aren't available
// - possibly no real concept of separate ClassLoaders?
@AndroidIncompatible
@GwtIncompatible
public class FinalizableReferenceQueueTest extends TestCase {

  private @Nullable FinalizableReferenceQueue frq;

  @Override

                    LOG.debug("Classloader cache miss for classpath : {}. Creating classloader.", libClasspath.getAsURIs());
                }
                // Lock is held while creating ClassLoader - nothing else can happen while this is running
                ClassLoader classLoader = factory.create();
                cachedClassLoader = new CachedClassLoader(libClasspath, classLoader);

        result instanceof String
        1 * classLoader.getResources("META-INF/services/java.lang.String") >> Collections.enumeration([serviceFile])
        1 * classLoader.loadClass('org.gradle.ImplClass') >> String
    }

    def "uses union of resources found in all ClassLoaders"() {
        def ClassLoader classLoader2 = Mock()
        def serviceLocator = new DefaultServiceLocator(classLoader, classLoader2)

            apply from: "script.gradle"

            try {
                getClass().classLoader.loadClass(pluginClass.name)
                assert false
            } catch (ClassNotFoundException ignore) {
                println "not in root"
            } finally {
                getClass().classLoader.close()
            }

        """

        file("script.gradle") << """

        then:
        consumerConnection.delegate.class != connectionImplementation //different classloaders
        consumerConnection.delegate.class.name == connectionImplementation.name
        consumerConnection.delegate.configured

        where:
        connectionImplementation | adapter

        result.assertNotOutput("service:")
    }

    @ToBeImplemented
    @Issue("https://github.com/gradle/gradle/issues/17559")
    def "service provided by a plugin cannot be shared by subprojects with different classloaders"() {
        createDirs("plugin1", "plugin2", "subproject1", "subproject2")
        settingsFile """
        pluginManagement {
            includeBuild 'plugin1'
            includeBuild 'plugin2'
        }

    // We are using a ConcurrentHashMap here because:
    //   - We don't want to use a Set with CLASS_COMPARATOR, since that would treat two classes with the same name originating from different classloaders as identical, allowing only one in the Set.
    //   - ConcurrentHashMap.newKeySet() isn't available on Java 6, yet, and that is where this code needs to run.

        and: 'classloader1 is reused'
        outputContains 'probe(classloader1) => 4'
        outputContains 'probe(classloader1) => 5'
        outputContains 'probe(classloader1) => 6'

        and: 'classloader2 is reused'
        outputContains 'probe(classloader2) => 4'
        outputContains 'probe(classloader2) => 5'
        outputContains 'probe(classloader2) => 6'
    }

    /**
     * Use a WeakHashMap here, so the keys (Class objects) can be garbage collected.
     * This approach prevents permgen space overflows due to retention of discarded
     * classloaders.
     */
    private static final Map<Class<?>, WeakReference<ClassMap>> CLASS_MAPS = new WeakHashMap<>();

    static final int EOF = -1;

    static final char PROPERTY_START = '.';