}

    public void addSourcePath(String sourcePath) {
        sourcePaths.add(sourcePath);
    }

    public void addSourcePaths(Set<String> sourcePath) {
        sourcePaths.addAll(sourcePath);
    }

    public Collection<String> getSourcePaths() {
        return Collections.unmodifiableCollection(sourcePaths);
    }

    public boolean isBuildNeeded() {

     *
     * @param sourcePaths Paths to source files for the copy
     */
    CopySourceSpec from(Object... sourcePaths);

    /**
     * Specifies the source files or directories for a copy and creates a child {@code CopySourceSpec}. The given source
     * path is evaluated as per {@link org.gradle.api.Project#files(Object...)} .
     *
     * @param sourcePath Path to source for the copy

    }

    public String getDeployPath() {
        return deployPath;
    }

    public void setDeployPath(String deployPath) {
        this.deployPath = deployPath;
    }

    public String getSourcePath() {
        return sourcePath;
    }

    public void setSourcePath(String sourcePath) {
        this.sourcePath = sourcePath;
    }

    @Override

            // There is currently a requirement in the JDK9 javac implementation
            // that when javac is invoked with an explicitly empty sourcepath
            // (i.e. {@code --sourcepath ""}), it won't allow you to compile a java 9
            // module. However, we really want to explicitly set an empty sourcepath
            // so that we don't implicitly pull in unrequested sourcefiles which

            }
        }

        val sourcePath = sourcePathFor(
            classPath = ClassPath.EMPTY,
            scriptFile = root.resolve("init.gradle.kts"),
            projectDir = folder("project"),
            gradleHomeDir = folder("gradle"),
            sourceDistributionResolver = mock()
        ).asFiles

        assertThat(
            sourcePath,
            hasItems(

    private File previousCompilationDataFile;

    public MinimalJavaCompileOptions(final CompileOptions compileOptions) {
        FileCollection sourcepath = compileOptions.getSourcepath();
        this.sourcepath = sourcepath == null ? null : ImmutableList.copyOf(sourcepath.getFiles());
        this.compilerArgs = Lists.newArrayList(compileOptions.getAllCompilerArgs());
        this.encoding = compileOptions.getEncoding();

        then:
        spec.scripts.values().each { script ->
            assert singleRequestModels[script].classPath == multiRequestsModels[script].classPath
            assert singleRequestModels[script].sourcePath == multiRequestsModels[script].sourcePath
            assert singleRequestModels[script].implicitImports == multiRequestsModels[script].implicitImports
        }
    }

    def "multi-scripts model is dehydrated over the wire"() {

    public String toString() {
        final Optional<String> sourcePath = this.sourcePath();
        final Optional<Integer> line = this.line();
        final Optional<Integer> column = this.pointer();

        if (sourcePath.isPresent() && line.isPresent() && column.isPresent()) {
            return sourcePath.get() + ":" + line.get() + ":" + (column.get() + 1);
        } else if (sourcePath.isPresent() && line.isPresent()) {

        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;

        super(library.getPath());
        this.library = library;
    }

    public FileReference getSourcePath() {
        return sourcePath;
    }

    public void setSourcePath(FileReference sourcePath) {
        this.sourcePath = sourcePath;
    }

    public FileReference getJavadocPath() {
        return javadocPath;
    }

    public void setJavadocPath(FileReference path) {