then:
        model.size() == 4
        model[0].message == "project :a classpath = 2"
        model[1].message == "project :b classpath = 1"
        model[2].message == "project :c classpath = 0"
        model[3].message == "project :d classpath = 0"

        and:
        fixture.assertStateStored {
            projectConfigured(":buildSrc")
            projectConfigured(":")

        override fun compilationClassPathOf(classLoaderScope: ClassLoaderScope): ClassPath =
            scriptCompilationClassPath

        override fun stage1BlocksAccessorsFor(scriptHost: KotlinScriptHost<*>): ClassPath =
            ClassPath.EMPTY

        override fun accessorsClassPathFor(scriptHost: KotlinScriptHost<*>): ClassPath =
            ClassPath.EMPTY

        then:
        EclipseClasspathFixture classpath = classpath('.')
        classpath.sourceDir('src/main/java').assertOutputLocation('bin/main')
        classpath.sourceDir('src/main/resources').assertOutputLocation('bin/main')
        classpath.sourceDir('src/test/java').assertOutputLocation('bin/test')
        classpath.sourceDir('src/test/resources').assertOutputLocation('bin/test')

    }

    @Override
    public ClassPath transform(ClassPath classPath, StandardTransform transform) {
        if (classPath.isEmpty()) {
            return classPath;
        }
        return transformPipelineFor(transform).transform(classPath);

    }

    @FunctionalInterface
    private interface TransformPipeline {
        ClassPath transform(ClassPath original);
    }

        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

        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']

    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

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

 */

package org.gradle.plugin.use.internal;

import org.gradle.internal.classpath.ClassPath;

public class InjectedPluginClasspath {

    private final ClassPath classPath;

    public InjectedPluginClasspath(ClassPath classPath) {
        this.classPath = classPath;
    }

    public ClassPath getClasspath() {
        return classPath;
    }