return Collections.unmodifiableCollection(resourcesToGenerate);
    }

    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);
    }

    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) {

            String existing = sourceState.get();
            if (!Objects.equals(current, existing)) {
                defaultConsumerPomArtifactTransformer.transform(project, session, src, target);
                Files.setLastModifiedTime(target, Files.getLastModifiedTime(src));
            }
            result = current;
        }
        sourceState.set(result);
        return result;
    }

     * path is evaluated as per {@link org.gradle.api.Project#files(Object...)} .
     *
     * @param sourcePath Path to source for the copy
     * @param configureClosure closure for configuring the child CopySourceSpec
     */
    CopySourceSpec from(Object sourcePath, @DelegatesTo(CopySpec.class) Closure configureClosure);

    /**

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