}
  }

  private void runTestMethod(ClassLoader classLoader) throws Exception {
    Class<?> test = classLoader.loadClass(AbstractFutureTest.class.getName());
    test.getMethod(getName()).invoke(test.getDeclaredConstructor().newInstance());
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
      throws Exception {

import java.util.concurrent.Callable;

/**
 * Simple guava-based classloader cache. Usually used with a very small size (< 10),
 * as classloaders are strongly referenced.
 *
 * Keeping them strongly referenced allows us to correctly release resources for the evicted entries.
 */
public class GuavaBackedClassLoaderCache<K> implements AutoCloseable {
    private final Cache<K, ClassLoader> cache;

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

        assertThat(System.getenv().get("TEST_ENV_VAR"), equalTo("value"));

        // Check ClassLoaders
        ClassLoader antClassLoader = Project.class.getClassLoader();
        ClassLoader thisClassLoader = getClass().getClassLoader();
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        assertThat(antClassLoader, sameInstance(systemClassLoader));

        def reply2 = originator.deserialize(receiver.serialize(received2))

        then:
        received1.class.classLoader == received2.class.classLoader
        received1.payload.class.classLoader == received2.payload.class.classLoader
        reply1.class == wrapperClass
        reply1.payload.class == payloadClass
        reply2.class == wrapperClass
        reply2.payload.class == payloadClass

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

 *
 * <p>Implementations are not required to be able to recreate the object, and should retain as little state as possible.
 * In particular, implementations should not hold on to user ClassLoaders.</p>
 */
public interface ValueSnapshot extends Hashable {
    /**

    private final DeserializeMap map;

    public PayloadSerializerObjectInputStream(InputStream inputStream, ClassLoader classLoader, Map<Short, ClassLoaderDetails> classLoaderDetails, DeserializeMap map) throws IOException {
        super(inputStream, classLoader);
        this.classLoaderDetails = classLoaderDetails;
        this.map = map;
    }

    @Override

import org.gradle.util.internal.GUtil;

import java.io.File;
import java.util.Properties;

/**
 * Gives the sample tests more metaspace, as we currently never collect old buildSrc/buildscript classloaders.
 */
public class MoreMemorySampleModifier implements SampleModifier {

    private static final String ORG_GRADLE_JVMARGS = "org.gradle.jvmargs";

    @Override
    public Sample modify(Sample sample) {

    }

    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