Collection<File> sourcepath = compileOptions.getSourcepath();
        boolean emptySourcePath = sourcepath == null || sourcepath.isEmpty();

        if (compilerArgs.contains("--module-source-path")) {
            if (!emptySourcePath) {
                LOGGER.warn("You specified both --module-source-path and a sourcepath. These options are mutually exclusive. Ignoring sourcepath.");
            }
            return;

        expect:
        builder.build() == defaultOptions
    }

    def "generates -sourcepath option"() {
        def file1 = new File("/lib/lib1.jar")
        def file2 = new File("/lib/lib2.jar")
        def fc = [file1, file2]
        spec.compileOptions.sourcepath = fc
        def expected = ["-g", "-sourcepath", GUtil.asPath(fc), "-proc:none", USE_UNSHARED_COMPILER_TABLE_OPTION, "-classpath", ""]

        expect:

            lateinit var sourceName: String
            lateinit var sourcePath: String
            if (productFlavorName.isNotEmpty()) {
                sourceName = buildTypeName
                sourcePath = sourceName
            } else {
                sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
                sourcePath = "${productFlavorName}/${buildTypeName}"
            }

        val classPath = base.nonProjectScriptPaths.bin + it.classPath
        val gradleKotlinDslJar = classPath.filter(::isGradleKotlinDslJar)
        val sourcePath = gradleKotlinDslJar + base.nonProjectScriptPaths.src + it.sourcePath
        buildOutputModel(it.scriptFile, classPath, sourcePath, base.implicitImports, base.classPathModeExceptions)
    }
}


private
fun buildScriptModelsInHierarchy(
    rootProject: ProjectInternal,

        buildTypes.each { buildTypeName ->
            def sourceName, sourcePath
            if (!productFlavorName) {
                sourceName = sourcePath = "${buildTypeName}"
            } else {
                sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
                sourcePath = "${productFlavorName}/${buildTypeName}"
            }

    private
    fun javaProjectBuilderFor(loader: ClassLoader, sourcePath: Set<File>): JavaProjectBuilder =
        JavaProjectBuilder(OrderedClassLibraryBuilder().apply {
            appendClassLoader(loader)
        }).apply {
            sourcePath.filter { it.extension == "java" }
                .forEach { sourceFile ->

    }

    @Override
    public CopySpec from(Object... sourcePaths) {
        return getDelegateCopySpec().from(sourcePaths);
    }

    @Override
    public CopySpec from(Object sourcePath, final Closure c) {
        return getDelegateCopySpec().from(sourcePath, new ClosureBackedAction<>(c));
    }

    @Override
    public CopySpec from(Object sourcePath, Action<? super CopySpec> configureAction) {

        }

        void assertHasSource(File jar) {
            assert entry.@sourcepath == jar.path.replace(File.separator, '/')
        }

        String getSourcePath() {
            entry.@sourcepath
        }

        void assertHasSource(String jar) {
            assert entry.@sourcepath == jar
        }

        void assertHasCachedSource(String group, String module, String version) {

                }
            }
        """

        expect:
        succeeds "compileJava"
    }

    def "handles -sourcepath being specified"() {
        goodCode()
        buildFile << """
            tasks.withType(JavaCompile) {
                options.sourcepath = project.layout.files()
            }
        """

        expect:
        succeeds "compileJava"
    }

    }

    def "ignores empty directories within the file collection of the sourcepath compiler option"() {
        given:
        def sourcePath = 'src/main/ignoredJava'
        buildFile << """
            plugins { id 'java' }
            compileJava.options.sourcepath = files('$sourcePath')
        """

        file("${sourcePath}/org/gradle/test/MyOptionalTest.java").text = """
            package org.gradle.test;