incrementSkipped(1);
    }

    @Override
    public void incrementSkipped(long amount) {
        skipped += amount;
        updateProgress();
    }

    public long getDeleted() {
        return deleted;
    }

    private void updateProgress() {
        buildOperationContext.progress(mandatoryNumber(deleted, " entry", " entries") + " deleted"

                    FileUtils.touch(gcFile);
                    LOGGER.info("{} cleaned up in {}.", cleanableStore.getDisplayName(), timer.getElapsed());
                    context.setResult(new CacheCleanupResult(progressMonitor.getDeleted(), lastCleanupTime));
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }

            @Override

    private boolean followSymlinks;

    @TaskAction
    protected void clean() throws IOException {
        boolean didWork = false;
        for (File path : paths) {
            didWork |= getDeleter().deleteRecursively(path, followSymlinks);
        }
        setDidWork(didWork);
    }

    /**
     * Returns the resolved set of files which will be deleted by this task.
     *

        ComponentState selectedPlatformComponent = platformModule.getSelected();
        List<String> sorted = Lists.newArrayListWithCapacity(participatingModules.size() + 1);
        sorted.add(selectedPlatformComponent.getVersion());
        for (ModuleResolveState module : participatingModules) {
            ComponentState selected = module.getSelected();
            if (selected != null) {

            return
        }
        if (!visited.add(dep.getSelected())) {
            return
        }
        String reason = dep.selected.selectionReason.conflictResolution? "(C)" : "";
        sb.append(indent + dep + reason + " [" + dep.selected.dependents*.from.id.module.join(",") + "]\n");
        for (DependencyResult d : dep.getSelected().getDependencies()) {
            printNode(d, sb, visited, "  " + indent);

        return dependency.getSelected().getSelectionReason();
    }

    @Override
    public List<ResolvedVariantResult> getSelectedVariants() {
        return dependency.getSelected().getVariants();
    }

    @Override
    public List<ResolvedVariantResult> getAllVariants() {
        return ((ResolvedComponentResultInternal) dependency.getSelected()).getAvailableVariants();
    }

    @Override

    }

    @Override
    public ResolvedComponentResult getSelected() {
        return selectedComponent;
    }

    @Override
    public ResolvedVariantResult getResolvedVariant() {
        return selectedVariant;
    }

    @Override
    public String toString() {
        if (getRequested().matchesStrictly(getSelected().getId())) {
            return getRequested().toString();
        } else {

			wantChanged.Insert(v.Name)
		}
	}

	gotDeleted := sets.New[string]()
	if usedDelta {
		gotDeleted.InsertAll(deleted...)
	}
	gotChanged := sets.New[string]()
	for _, v := range deltaRes {
		gotChanged.Insert(v.Name)
	}

	// BUGS
	extraDeletes := sets.SortedList(gotDeleted.Difference(wantDeleted))
	missedDeletes := sets.SortedList(wantDeleted.Difference(gotDeleted))

        delete.delete("someFile")
        delete.delete(new File("someOtherFile"))
        delete.getTargetFiles()

        then:
        delete.getDelete() == WrapUtil.toSet("someFile", new File("someOtherFile"))
        delete.getTargetFiles().getFiles() == getProject().files(delete.getDelete()).getFiles()
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can follow symlinks"() {
        given:

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

    @Inject
    protected Deleter getDeleter() {
        throw new UnsupportedOperationException("Decorator takes care of injection");
    }