class ClassLoaderLeakAvoidanceSoakTest extends AbstractIntegrationSpec {

    def setup() {
        executer.requireDaemon().requireIsolatedDaemons()
    }

    def "convention mapping does not leak old classloaders"() {
        given:
        def myTask = file("buildSrc/src/main/groovy/MyTask.groovy") << """
            import org.gradle.api.*
            import org.gradle.api.tasks.*

            baseScope,
            topLevelScript
        )
    }

    override fun close() {
        classLoaders.forEach(URLClassLoader::close)
    }

    private
    val classLoaders = mutableListOf<URLClassLoader>()

    private
    val parentClassLoader = mock<ClassLoader>()

    private
    val baseScope = mock<ClassLoaderScope>(name = "baseScope") {

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * A {@code ClassLoader} which delegates to multiple parent ClassLoaders.
 *
 * Note: It's usually a good idea to add a {@link CachingClassLoader} between this ClassLoader and any
 * ClassLoaders that use it as a parent, to prevent every path in the ClassLoader graph being searched.
 */
public class MultiParentClassLoader extends ClassLoader implements ClassLoaderHierarchy {

     * 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.

import org.gradle.internal.classloader.ClassLoaderSpec;

import java.util.List;

/**
 * Used to create ClassLoaders used to serialize objects between the tooling api provider and daemon.
 *
 * <p>Implementations are not required to be thread-safe.</p>
 */
public interface PayloadClassLoaderFactory {
    ClassLoader getClassLoaderFor(ClassLoaderSpec spec, List<? extends ClassLoader> parents);

     */
    void shutdown();

    /**
     * Invoked when another ClassLoader is discarded, so that this Groovy system can remove state for the classes loaded from the ClassLoader
     */
    void discardTypesFrom(ClassLoader classLoader);

  }

  private static ClassLoader getClassLoader(final Set<String> blocklist) {
    final String concurrentPackage = SettableFuture.class.getPackage().getName();
    ClassLoader classLoader = AggregateFutureStateFallbackAtomicHelperTest.class.getClassLoader();
    // we delegate to the current classloader so both loaders agree on classes like TestCase

  }

  private static ClassLoader getClassLoader(final Set<String> blocklist) {
    final String concurrentPackage = SettableFuture.class.getPackage().getName();
    ClassLoader classLoader = AggregateFutureStateFallbackAtomicHelperTest.class.getClassLoader();
    // we delegate to the current classloader so both loaders agree on classes like TestCase

     * @param spec the filtering spec for the classloader
     * @return The ClassLoader
     */
    ClassLoader createFilteringClassLoader(ClassLoader parent, FilteringClassLoader.Spec spec);

    }
  }

  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 {