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)

        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
    }

// 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
    }

 */
@Incubating
public interface JavaResolutionConsistency {
    /**
     * Configures the runtime classpath of every source set to be consistent
     * with the compile classpath. For dependencies which are common between
     * the compile classpath and the runtime classpath, the version from the
     * compile classpath is going to be used.
     *
     * Unless you have a good reason to, this option should be preferred to

    private final EclipseClasspath classpath;
    private final EclipseDependenciesCreator dependenciesCreator;

    public ClasspathFactory(EclipseClasspath classpath, IdeArtifactRegistry ideArtifactRegistry, GradleApiSourcesResolver gradleApiSourcesResolver, boolean inferModulePath) {
        this.classpath = classpath;

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

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

    @Override
    public JavaExecSpec classpath(Object... paths) {
        this.classpath.from(paths);
        return this;
    }

    @Override
    public FileCollection getClasspath() {
        return classpath;
    }

    @Override
    public JavaExecSpec setClasspath(FileCollection classpath) {
        this.classpath = fileCollectionFactory.configurableFiles("classpath");
        this.classpath.setFrom(classpath);

        project.assertHasJavaFacetBuilders()

        // Classpath
        def classpath = classpath
        classpath.assertHasLibs('jstl-1.2.jar', 'guava-18.0.jar', 'javax.servlet-api-3.1.0.jar', 'junit-4.13.jar', 'hamcrest-core-1.3.jar')
        classpath.lib('guava-18.0.jar').assertIsDeployedTo("/WEB-INF/lib")
        classpath.lib('jstl-1.2.jar').assertIsExcludedFromDeployment()
        classpath.lib('junit-4.13.jar').assertIsExcludedFromDeployment()

        if (needJaxpImpl()) {
            classPath = addToClassPath(classPath, getClasspathForResource(getSystemClassLoader(), "META-INF/services/javax.xml.parsers.SAXParserFactory"));
            classPath = addToClassPath(classPath, getClasspathForClass("org.w3c.dom.ElementTraversal"));
        }

        return doCreateClassLoader(name, getIsolatedSystemClassLoader(), classPath);
    }

        }
        when:
        def classpath = project.scalaRuntime.inferScalaClasspath([new File("other.jar"), new File("scala-library-2.10.1.jar")])
        then:
        assertHasCorrectDependencies(classpath, useZincVersion)
    }

    private void assertHasCorrectDependencies(classpath, zincVersion) {
        assert classpath instanceof LazilyInitializedFileCollection
        assert classpath.sourceCollections.size() == 1