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

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

            } else {
                DefaultResolvedComponentResult selectedComponent = components.get(d.getSelected().longValue());
                if (selectedComponent == null) {
                    throw new IllegalStateException("Corrupt serialized resolution result. Cannot find selected component (" + d.getSelected() + ") for " + (d.isConstraint() ? "constraint " : "") + fromVariant + " -> " + d.getRequested().getDisplayName());

                if (d instanceof ResolvedDependencyResult) {
                    ResolvedDependencyResult resolved = (ResolvedDependencyResult) d;
                    ResolvedComponentResult selected = resolved.getSelected();
                    if (seen.add(selected)) {
                        pending.push(selected);
                    }
                }
            }
        }

        return null;
    }

     * and added to the graph.
     * On resolve failure, the failure is recorded and no `ComponentState` is selected.
     */
    private static void performSelection(ResolveState resolveState, ModuleResolveState module) {
        ComponentState currentSelection = module.getSelected();

        try {

                if (details.reason != null) {
                    conflictResolution = conflictResolution.withDescription(details.reason);
                }
                details.getSelected().addCause(conflictResolution);
                return;
            }
        }
    }

    @Override
    public boolean hasSeenCapability(Capability capability) {

            Set<ModuleResolveState> modules = platformState.getParticipatingModules();
            for (ModuleResolveState module : modules) {
                ComponentState selected = module.getSelected();
                if (selected != null) {
                    String componentVersion = selected.getId().getVersion();
                    for (String target : candidateVersions) {

        resolver.select(details);
        if (details.hasFailure()) {
            throw UncheckedException.throwAsUncheckedException(details.getFailure());
        }
        ComponentResolutionState selected = details.getSelected();
        ConflictResolutionResult result = new DefaultConflictResolutionResult(conflict.participants, selected);
        resolutionAction.execute(result);
        if (selected != null) {

        }
        return selectedComponent.getMetadataResolveFailure();
    }

    @Override
    public Long getSelected() {
        return getSelectedComponent().getResultId();
    }

    @Override
    public boolean isTargetVirtualPlatform() {
        ComponentState selectedComponent = getSelectedComponent();