executer.withTasks("eclipse").run()

        def libs = classpath("a").libs
        assert classpath("a").projects.collect { it.name } == ['b']
        assert libs.size() == 1
        libs[0].assertHasJar(someLib2Jar)

        executer.withArgument("-PstrictDeps=true").withTasks("eclipse").run()

        libs = classpath("a").libs
        assert classpath("a").projects.collect { it.name } == ['b']

public abstract class GenerateEclipseClasspath extends XmlGeneratorTask<Classpath> {

    private EclipseClasspath classpath;

    public GenerateEclipseClasspath() {
        getXmlTransformer().setIndentation("\t");
    }

    @Inject
    public GenerateEclipseClasspath(EclipseClasspath classpath) {
        this.classpath = classpath;
    }

    @Override
    protected Classpath create() {

        // the entire set of framework implementation dependencies from the distribution in order to ensure that all implementation
        // dependencies on the classpath share a version. This can _still_ lead to duplicates on the classpath, but it is at least
        // avoidable if the user adds junit-platform-launcher to their test runtime classpath, which they should be doing, since

        then:
        0 * configuration._
        0 * buildLogicBuilder.resolveClassPath(_, _)

        and:
        classpath == ClassPath.EMPTY
    }

    def "resolves classpath configuration when configuration container has been queried"() {
        def classpath = Mock(ClassPath)

        when:
        handler.configurations

    private final List<URI> classpath;

    public ClientOwnedClassLoaderSpec(List<URI> classpath) {
        this.classpath = classpath;
    }

    public List<URI> getClasspath() {
        return classpath;
    }

    @Override
    public String toString() {
        return "{client-owned-class-loader classpath: " + classpath + "}";
    }

    @Override

import org.gradle.api.internal.classpath.ModuleRegistry
import org.gradle.api.internal.file.FileCollectionFactory
import org.gradle.api.internal.initialization.ClassLoaderScope
import org.gradle.internal.classloader.ClassLoaderVisitor
import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.kotlin.dsl.support.isGradleKotlinDslJar

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

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

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