getTempDir() >> tempDir
            getSourceFiles() >> [ sourceFile ]
        }

        when:
        transformer.transform(spec)

        then:
        spec.setSourceFiles(_) >> { args ->
            def sourceFiles = args[0]
            assert sourceFiles.size() == 1
            assert sourceFiles[0].name == "test.c"
            assert sourceFiles[0].parentFile == pchSourceDir

    }

    private <T extends JavaCompileSpec> Compiler<T> createRebuildAllCompiler(CleaningJavaCompiler<T> cleaningJavaCompiler, FileTree sourceFiles) {
        return spec -> {
            spec.setSourceFiles(sourceFiles);
            return cleaningJavaCompiler.execute(spec);
        };
    }

    File getWorkingDir();

    void setWorkingDir(File workingDir);

    File getDestinationDir();

    void setDestinationDir(File destinationDir);

    Iterable<File> getSourceFiles();

    void setSourceFiles(Iterable<File> sourceFiles);

    List<File> getCompileClasspath();

    void setCompileClasspath(List<File> classpath);

    @Nullable
    Integer getRelease();

    void include(File... includeRoots);

    List<File> getSystemIncludeRoots();

    void systemInclude(Iterable<File> systemIncludeRoots);

    List<File> getSourceFiles();

    void setSourceFiles(Collection<File> sources);

    void source(Iterable<File> sources);

    List<File> getRemovedSourceFiles();

    void setRemovedSourceFiles(Collection<File> sources);

                for (File sourceFile : original.getSourceFiles()) {
                    newSourceFiles.add(generatePCHSourceFile(original, sourceFile));
                }
                original.setSourceFiles(newSourceFiles);
                return original;
            }
        };
    }

    private static String getSourceFileExtension(Class<? extends NativeCompileSpec> specClass) {

        this.tempDir = tempDir;
    }

    @Override
    public Iterable<File> getSourceFiles() {
        return sourceFiles;
    }

    @Override
    public void setSourceFiles(Iterable<File> sourceFiles) {
        this.sourceFiles = sourceFiles;
    }

    @Override
    public List<File> getCompileClasspath() {
        if (classpath == null) {
            classpath = ImmutableList.of();

        // which silently excludes files not ending in .java
        Iterable<File> javaOnly = Iterables.filter(spec.getSourceFiles(), NormalizingJavaCompiler::hasJavaExtension);
        spec.setSourceFiles(ImmutableSet.copyOf(javaOnly));
    }

    private static boolean hasJavaExtension(@Nullable File input) {
        return hasExtension(input, ".java");
    }

        compilation.getRecompile() >> [newSource]
        compilation.getRemoved() >> [removedSource]

        and:
        compiler.doIncrementalCompile(compilation, spec)

        then:
        1 * spec.setSourceFiles([newSource])
        1 * spec.setRemovedSourceFiles([removedSource])
        1 * delegateCompiler.execute(spec)
    }

    def "cleans outputs and delegates spec for clean compilation"() {

                            // Classes compiled as a result of being on the -sourcepath do not have the annotation processor run against them
                            spec.setSourceFiles(Iterables.concat(spec.getSourceFiles(), projectLayout.files(stubDir).getAsFileTree()));
                        } else {

    }

    @Override
    public CompileTransaction initCompilationSpecAndTransaction(JavaCompileSpec spec, RecompilationSpec recompilationSpec) {
        if (!recompilationSpec.isBuildNeeded()) {
            spec.setSourceFiles(ImmutableSet.of());
            spec.setClassesToProcess(Collections.emptySet());
            return new CompileTransaction(spec, fileOperations.patternSet(), ImmutableMap.of(), fileOperations, deleter);
        }