return "{details=" + details + " classloaders=" + classLoaders + "}";
        }

        Set<ClassLoader> getClassLoaders() {
            Set<ClassLoader> candidates = new LinkedHashSet<>();
            for (WeakReference<ClassLoader> reference : classLoaders) {
                ClassLoader classLoader = reference.get();
                if (classLoader != null) {
                    candidates.add(classLoader);

                classRealm.importFromParent(imp);
            }
        }
    }

    private static Object getId(ClassLoader classLoader) {
        if (classLoader instanceof ClassRealm) {
            return ((ClassRealm) classLoader).getId();
        }
        return 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

    // 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 = '.';

    localSourcePath: ClassPath
): IntermediateScriptModel? {

    val buildScript = project.discoverBuildScript()
        ?: return null

    // TODO:isolated this relies on the hierarchy of classloaders
    val compilationClassPath = project.scriptCompilationClassPath

    val accessorsClassPath = project.serviceOf<ClassPathModeExceptionCollector>().runCatching {
        project.accessorsClassPathOf(compilationClassPath)

        // NOTE: We do not want/need a decorated version of JavaForkOptions or JavaDebugOptions because
        // these immutable instances are held across builds and will retain classloaders/services in the decorated object