}

    def "Source folder defines additional classpath attributes"() {
        buildFile <<
            """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->

            runner('helloWorld')
                .buildAndFail()
        }

        then:
        !execFailure(result).error.contains("Gradle TestKit (classpath:")
    }

    @InspectsBuildOutput
    def "explicit classpath takes precedence over conventional classpath"() {
        given:
        def explicitClasspath = [file('does/not/exist')]

        when:
        def result = pluginUnderTest.exposeMetadata {

        }
        return delegate.getClassLoaderFor(spec, parents);
    }

    private List<URL> urls(List<URI> classpath) {
        List<URL> urls = new ArrayList<>(classpath.size());
        for (URI uri : classpath) {
            try {
                urls.add(uri.toURL());
            } catch (MalformedURLException e) {

    }

    protected findEntries(classpath, kind) {
        classpath.classpathentry.findAll { it.@kind == kind }
    }

    protected libEntriesInClasspathFileHaveFilenames(String... filenames) {
        def classpath = parseClasspathFile()
        def libs = findEntries(classpath, "lib")
        assert libs*.@path*.text().collect { new File(it).name } as Set == filenames as Set

    }

    /**
     * Specifies classpath URIs used for loading user-defined classes. This list is in addition to the default classpath.
     *
     * @param classpath Classpath URIs
     * @return this
     * @since 2.8
     */
    public T withInjectedClassPath(ClassPath classpath) {
        operationParamsBuilder.setInjectedPluginClasspath(classpath);
        return getThis();
    }

        return "eclipseClasspath"
    }

    @Override
    void ideFileContainsEntry(String jar, List<String> sources, List<String> javadoc) {
        def classpath = EclipseClasspathFixture.create(testDirectory, executer.gradleUserHomeDir)
        def lib = classpath.lib(jar)

        // Eclipse only retains the first source/javadoc file
        if (!sources.isEmpty()) {
            assert lib.sourcePath != null: "no sources attached"

import org.gradle.cache.GlobalCacheLocations;
import org.gradle.internal.classpath.ClasspathWalker;
import org.gradle.internal.classpath.InPlaceClasspathBuilder;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactory;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForAgent;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForLegacy;

object SourcePathProvider {

    fun sourcePathFor(
        classPath: ClassPath,
        scriptFile: File?,
        projectDir: File,
        gradleHomeDir: File?,
        sourceDistributionResolver: SourceDistributionProvider
    ): ClassPath {
        val gradleKotlinDslJar = classPath.filter(::isGradleKotlinDslJar)

 * the Kotlin version.
 */
class KotlinExtensionsForGradleApiFacade(classPath: ClassPath) : AutoCloseable {

    private
    val loader: URLClassLoader

    init {
        loader = DefaultClassLoaderFactory().createIsolatedClassLoader(
            KotlinExtensionsForGradleApiFacade::class.java.simpleName,
            classPath
        ) as URLClassLoader
    }

    /**

        def testSrcDir = project.sourceDirectories.find { it.path == 'src/test/java' }
        def guava = project.classpath.find { it.file.name.contains 'guava' }
        def junit = project.classpath.find { it.file.name.contains 'junit' }

        then:
        !hasTestAttributes(mainSrcDir)

        and:
        hasTestAttributes(testSrcDir)

        and: