def "Source folder defines one classpath attribute"() {
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
            """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->

    private final AtomicBoolean stopped = new AtomicBoolean();

    // Protects the following fields
    private final Lock lock;
    private final Map<ClassPath, Cleanup> cleanups;
    private final Map<ClassPath, CacheEntry> cacheEntries;

    public FinalizerThread(Map<ClassPath, CacheEntry> cacheEntries, Lock lock) {
        this.setName("Classloader cache reference queue poller");
        this.setDaemon(true);

 *       }
 *
 *       //closure executed after .classpath content is loaded from existing file
 *       //but before gradle build information is merged
 *       beforeMerged { classpath ->
 *         //you can tinker with the {@link Classpath} here
 *       }
 *
 *       //closure executed after .classpath content is loaded from existing file
 *       //and after gradle build information is merged

// tag::module-before-merged[]
// tag::module-when-merged[]
eclipse.classpath.file {
// end::module-when-merged[]
    beforeMerged { classpath ->
        classpath.entries.removeAll { entry -> entry.kind == 'lib' || entry.kind == 'var' }
    }
// end::module-before-merged[]
// tag::module-when-merged[]
    whenMerged { classpath ->
        classpath.entries.findAll { entry -> entry.kind == 'lib' }*.exported = false
    }

        private final EclipseClasspath classpath;
        private final Set<File> files = new LinkedHashSet<>();

        private WtpClasspathAttributeDependencyVisitor(EclipseClasspath classpath) {
            this.classpath = classpath;
        }

        @Override
        public boolean isOffline() {
            return classpath.isProjectDependenciesOnly();
        }

        @Override

        return new URLClassLoader(classPath.getAsURLArray(), parent);
    }

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

    @Override

        when:
        def classPath = canonicalClassPath()

        then:
        assertThat(
            classPath.collect { it.name } as List<String>,
            hasItems("classes.jar")
        )

        assertContainsBuildSrc(classPath)

        assertContainsGradleKotlinDslJars(classPath)
    }

    def "can fetch buildscript classpath for sub-project script when parent has errors"() {

        given:

import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.util.GradleVersion

class ExternalToolingApiDistribution implements ToolingApiDistribution {
    private final GradleVersion version
    private final Collection<File> classpath

    ExternalToolingApiDistribution(String version, Collection<File> classpath) {
        this.version = GradleVersion.version(version)

        def classpath = project.eclipse.classpath
        def classpathTask = project.tasks.eclipseClasspath

        assert classpathTask instanceof GenerateEclipseClasspath
        assert classpathTask.classpath == classpath
        assert classpathTask.outputFile == project.file('.classpath')

        e.message == 'unknown classpath \'name\' requested.'
    }

    def "delegates to providers to find classpath"() {
        def classpath = Mock(ClassPath)

        given:
        provider1.findClassPath(_) >> null
        provider2.findClassPath("name") >> classpath

        expect:
        registry.getClassPath("name") == classpath
    }