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

        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)

 */

package org.gradle.api.internal.initialization.loadercache;

import org.gradle.api.Describable;

/**
 * Opaque identifier of the classloader. Needed for correct behavior of classloader invalidation.
 */
public interface ClassLoaderId extends Describable {
    @Override
    boolean equals(Object o);
    @Override
    int hashCode();

            visitedClassLoaders.put(classLoader, true)

            val record = ClassLoaderNode(idOf(classLoader), classLoader.toString())
            classLoaders.add(record)

            stack.push(record)
            super.visit(classLoader)
            stack.pop()
        }

        override fun visitParent(classLoader: ClassLoader) {
            current.parents.add(idOf(classLoader))

     * @return the classloader.
     */
    ClassLoader createIfAbsent(ClassLoaderId id, ClassPath classPath, @Nullable ClassLoader parent, Function<ClassLoader, ClassLoader> factoryFunction, @Nullable HashCode implementationHash);

    /**
     * Discards the given classloader.
     */
    void remove(ClassLoaderId id);

     * Creates a {@link ClassLoader} with the given parent and classpath. Use the given hash
     * code, or calculate it from the given classpath when hash code is {@code null}.
     */
    ClassLoader createChildClassLoader(String name, ClassLoader parent, ClassPath classPath, @Nullable HashCode implementationHash);

    /**
     * Returns the hash associated with the classloader's classpath, or {@code null} if the classloader is unknown to Gradle.

    }

    override fun classloaderCreated(scopeId: ClassLoaderScopeId, classLoaderId: ClassLoaderId, classLoader: ClassLoader, classPath: ClassPath, implementationHash: HashCode?) {
        synchronized(lock) {
            val spec = scopeSpecs[scopeId]
            require(spec != null)
            // TODO - a scope can currently potentially have multiple export and local ClassLoaders but we're assuming one here

        DefaultClassPath.of(paths.collect { file(it) } as Iterable<File>)
    }

    ClassLoader classLoader(ClassPath classPath) {
        new URLClassLoader(classPath.asURLArray)
    }

    def "class loaders are reused when parent, class path and implementation hash are the same"() {
        expect:
        def root = classLoader(classPath("root"))

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

        expect:
        hasher.getClassLoaderHash(classLoader) == null
    }

    private ConfigurableClassLoaderHierarchyHasher hasher(Map<ClassLoader, String> classLoaders) {
        classLoaders = new HashMap<>(classLoaders)
        classLoaders.put(ClassLoader.getSystemClassLoader(), "system")
        return new ConfigurableClassLoaderHierarchyHasher(classLoaders, classLoaderFactory)
    }