expect:
        StaleOutputCleaner.cleanOutputs(deleter, files(file1, file2), tmpDir.testDirectory)
        !file1.exists()
        !file2.exists()
    }

    def "deletes empty parent directories"() {
        def file1 = tmpDir.file('foo/bar/file1').createFile()
        tmpDir.file('foo/baz/file2').createFile()

        expect:
        StaleOutputCleaner.cleanOutputs(deleter, files(file1), tmpDir.testDirectory)

     *
     * Returns {code true} if any file or directory was deleted, {@code false} otherwise.
     */
    @CheckReturnValue
    public static boolean cleanOutputs(Deleter deleter, Iterable<File> filesToDelete, File directoryToClean) {
        return cleanOutputs(deleter, filesToDelete, ImmutableSet.of(directoryToClean));
    }

    /**
     * Clean up the given stale output files under the given directories.
     *

 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class ProcessResources extends Copy {

    @Override
    protected void copy() {
        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(getDeleter(), getOutputs().getPreviousOutputFiles(), getDestinationDir());
        super.copy();
        if (cleanedOutputs) {
            setDidWork(true);
        }
    }

    @Inject

        addDirectoryIfNotNull(outputDirs, compileOptions.getHeaderOutputDirectory());
        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(deleter, taskOutputs.getPreviousOutputFiles(), outputDirs.build());

        Compiler<? super T> compiler = getCompiler();
        return compiler.execute(spec)
            .or(WorkResults.didWork(cleanedOutputs));
    }

            .withOutputBaseFolder(objectFileRoot)
            .map(sourceFile);
    }

    private boolean cleanPreviousOutputs(SwiftCompileSpec spec) {
        return StaleOutputCleaner.cleanOutputs(deleter, outputs.getPreviousOutputFiles(), spec.getObjectFileDir());
    }

            return WorkResults.didWork(true);
        }
        return compileResult;
    }

    private boolean cleanPreviousOutputs(NativeCompileSpec spec) {
        return StaleOutputCleaner.cleanOutputs(deleter, outputs.getPreviousOutputFiles(), spec.getObjectFileDir());
    }

    @TaskAction
    public void assemble() {
        BuildOperationLogger operationLogger = getOperationLoggerFactory().newOperationLogger(getName(), getTemporaryDir());

        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(
            getDeleter(),
            getOutputs().getPreviousOutputFiles(),
            getObjectFileDir()
        );

        DefaultAssembleSpec spec = new DefaultAssembleSpec();

        throw new UnsupportedOperationException("Decorator takes care of injection");
    }

    @TaskAction
    protected void link() {
        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(
            getDeleter(),
            getOutputs().getPreviousOutputFiles(),
            getDestinationDirectory().get().getAsFile()
        );

        if (getSource().isEmpty()) {

        Map<GeneratedResource.Location, PatternSet> resourcesToDelete = getNewGeneratedResources(compilerResult);
        Set<File> filesToDelete = collectFilesToDelete(classesToDelete, resourcesToDelete);
        StaleOutputCleaner.cleanOutputs(deleter, filesToDelete, getOutputDirectories());
        if (LOG.isDebugEnabled()) {
            LOG.debug("Deleting generated files: {}", filesToDelete.stream().sorted().collect(Collectors.toList()));
        }
    }

	if err != nil {
		return nil, errors.Wrap(err, "cannot execute 'kubelet --version'")
	}

	cleanOutput := strings.TrimSpace(string(out))
	subs := kubeletVersionRegex.FindAllStringSubmatch(cleanOutput, -1)
	if len(subs) != 1 || len(subs[0]) < 2 {
		return nil, errors.Errorf("Unable to parse output from Kubelet: %q", cleanOutput)
	}
	return version.ParseSemantic(subs[0][1])