factory.getClassPathFor(cl, classpath)
        return classpath.collect { it.toURL() }
    }

    /**
     * A classloader that produces classes with CodeSource objects containing the full resource URL,
     * similar to how the NetBeans JarClassLoader works.
     */
    class NetBeansLikeClassLoader extends TestClassLoader {
        NetBeansLikeClassLoader(ClassLoader classLoader, List<File> classpath) {

        if (additionalLoaders == null) {
            return loader(id, parent, classPath);
        }
        return new CachingClassLoader(multiLoader(id, parent, classPath, additionalLoaders));
    }

    writeCollection(classPath.asFiles) {
        writeFile(it)
    }
}


internal
fun Encoder.writeTransformedClassPath(classPath: TransformedClassPath) {
    writeCollection(classPath.asFiles.zip(classPath.asTransformedFiles)) {
        writeFile(it.first)
        writeFile(it.second)
    }
}


internal
fun Decoder.readClassPath(): ClassPath {
    val isTransformed = readBoolean()

            classpath = classpath.plus(moduleRegistry.getModule("gradle-dependency-management").getAllRequiredModulesClasspath());
            classpath = classpath.plus(moduleRegistry.getModule("gradle-plugin-use").getAllRequiredModulesClasspath());
            classpath = classpath.plus(moduleRegistry.getModule("gradle-workers").getAllRequiredModulesClasspath());

import org.gradle.internal.classloader.FilteringClassLoader
import org.gradle.internal.classpath.transforms.ClassTransform
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForAgent
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForLegacy
import org.gradle.internal.classpath.types.GradleCoreInstrumentationTypeRegistry
import org.gradle.internal.configuration.inputs.InstrumentedInputs

        }

        ScriptHandlerScope(buildscript).apply {
            dependencies {
                classpath(notation)
                classpath(notation) { exclude(module = "com.google.guava") }
            }
        }

        verify(dependencies).add(eq("classpath"), eq(notation))
        verify(dependencies).addProvider(eq("classpath"), eq(notation), any<Action<ExternalModuleDependency>>())

    repositories {
        maven {
            url = '$mavenRepo.uri'
        }
    }
    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
    dependencies {
        classpath 'org.foo:foo-plugin:[1.0,2.0)'
    }
}
"""
        lockfileFixture.createBuildscriptLockfile('classpath', ['org.foo:foo-plugin:1.0'], unique)

        when:
        succeeds 'buildEnvironment'

        then:

    return o as T
}


inline fun withClassLoaderFor(vararg classPath: File, action: ClassLoader.() -> Unit) =
    classLoaderFor(*classPath).use(action)


inline fun withClassLoaderFor(classPath: ClassPath, action: ClassLoader.() -> Unit) =
    classLoaderFor(classPath).use(action)


fun classLoaderFor(classPath: ClassPath): URLClassLoader =
    classLoaderFor(*classPath.asFiles.toTypedArray())

    }

    @Override
    public ClassLoader get(ClassLoaderId id, ClassPath classPath, @Nullable ClassLoader parent, @Nullable FilteringClassLoader.Spec filterSpec) {
        return get(id, classPath, parent, filterSpec, null);
    }

    @Override

    def "creates a limited implementation classpath"() {
        when:
        def framework = newFramework(false, [], [], [], [])
        def classpath = underTest.create([new File("cls.jar")], [new File("mod.jar")], framework, false)

        then:
        classpath.applicationClasspath == [new File("cls.jar")]
        classpath.applicationModulepath == [new File("mod.jar")]