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

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

            assertThat(hierarchy.classLoaders.size, equalTo(3))
            assertThat(hierarchy.scopes.size, equalTo(1))
            assertThat(hierarchy.classLoaders[0].parents, hasItem(hierarchy.classLoaders[1].id))
            assertThat(hierarchy.scopes[0].label, equalTo("the path"))
            assertThat(hierarchy.scopes[0].localClassLoader, equalTo(hierarchy.classLoaders[0].id))

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

        return cache.getDetails(classLoader, classLoaderToDetails);
    }

    private static class ClassLoaderSpecVisitor extends ClassLoaderVisitor {
        final ClassLoader classLoader;
        final List<ClassLoader> parents = new ArrayList<>();
        ClassLoaderSpec spec;
        URL[] classPath;

        public ClassLoaderSpecVisitor(ClassLoader classLoader) {

    private final boolean useCaches;
    private final List<ClassLoader> classLoaders;

    public DefaultServiceLocator(ClassLoader... classLoaders) {
        this(true, classLoaders);
    }

    public DefaultServiceLocator(boolean useCaches, ClassLoader... classLoaders) {
        this.useCaches = useCaches;
        this.classLoaders = Arrays.asList(classLoaders);
    }

    @Override

            buildscript {
                require(Thread.currentThread().contextClassLoader === this@Settings_gradle.javaClass.classLoader)
                println("stage 1")
            }

            require(Thread.currentThread().contextClassLoader === this@Settings_gradle.javaClass.classLoader)
            println("stage 2")

        """.trimIndent()

        val sourceHash = TestHashCodes.hashCodeFrom(42)

/**
 * Provides a combined hash for a hierarchy of classloaders.
 */
public interface ClassLoaderHierarchyHasher {
    /**
     * Returns a hash for the given classloader hierarchy, or {@code null}
     * if the hierarchy contains any classloaders that are not known to Gradle.
     */
    @Nullable
    HashCode getClassLoaderHash(ClassLoader classLoader);

import org.gradle.integtests.fixtures.longlived.PersistentBuildProcessIntegrationTest

class ConfigurationCacheClassLoaderCachingIntegrationTest extends PersistentBuildProcessIntegrationTest {

    def "reuses cached ClassLoaders"() {

        given: 'a Task that holds some static data'
        File staticDataLib = file("lib/StaticData.jar").tap {
            parentFile.mkdirs()
        }
        jarWithClasses(
            staticDataLib,

            } finally {
                IoActions.closeQuietly(objectStream);
            }

            Map<Short, ClassLoaderDetails> classLoaders = new HashMap<Short, ClassLoaderDetails>();
            map.collectClassLoaderDefinitions(classLoaders);
            return new SerializedPayload(classLoaders, buffer.readAsListOfByteArrays());
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }