}
        ImmutableList<String> reasons = context.getRebuildReasons();
        return context.getChanges()
            .filter(__ -> reasons.isEmpty())
            .map(changes -> skipExecution(work, context))
            .orElseGet(() -> executeBecause(work, reasons, context));
    }

    private UpToDateResult skipExecution(UnitOfWork work, C context) {

        );
    }

    private boolean isVisible(String group) {
        if (Strings.isNullOrEmpty(group)) {
            return detail;
        } else {
            return groupsOfInterest.isEmpty() || groupsOfInterest.contains(group.toLowerCase());
        }
    }

    @Override
    public Set<String> getGroups() {
        return groups.keySet();
    }

    @Override

        if (files.isEmpty()) {
            return FileCollectionFactory.empty();
        }
        return fixed(FileCollectionInternal.DEFAULT_COLLECTION_DISPLAY_NAME, files);
    }

    @Override
    public FileCollectionInternal fixed(final String displayName, Collection<File> files) {
        if (files.isEmpty()) {
            return new EmptyFileCollection(displayName);

            }
        }
        return this;
    }

    @Override
    public ExecutionFailure assertHasNoCause() {
        for (Problem problem : problems) {
            if (!problem.causes.isEmpty()) {
                failureOnUnexpectedOutput(String.format("Expected no failure with a cause, found: %s", problem.causes.get(0)));
            }
        }
        return this;
    }

    @Override

    }

    void sendProblemSummaries() {
        List<InternalProblemAggregationVersion3> problemSummaries = createSummaries();

        if (problemSummaries.isEmpty()) {
            seenProblems.clear();
            return;
        }

        problemSummaries.forEach(summary -> {

        }

        public void append(String name, @Nullable Object value) {
            if (value != null
                && !((value instanceof Collection) && ((Collection) value).isEmpty())
                && !((value instanceof String) && StringUtils.isEmpty((String) value))
                && !((value instanceof Integer) && ((Integer) value == 0))) {
                if (anyArgs) {
                    builder.append(',');
                }

                + ":" + artifact.getArtifactId()
                + ":" + artifact.getArtifactHandler().getExtension()
                + (artifact.getClassifier() == null || artifact.getClassifier().isEmpty()
                        ? ""
                        : ":" + artifact.getClassifier())
                + ":" + artifact.getVersion();
    }

    private String id(Artifact artifact) {

    @Override
    public Set<InstallationLocation> get() {
        final Collection<String> property = buildOptions.getInstallationsFromPaths();
        return property.stream()
            .filter(path -> !path.trim().isEmpty())
            .map(this::asInstallations).collect(Collectors.toSet());
    }

    private InstallationLocation asInstallations(String candidate) {

        this.accessibleClassDependencies = ImmutableSet.copyOf(accessibleClassDependencies);
        this.dependencyToAllReason = dependencyToAllReason;
        this.constants = constants.isEmpty() ? IntSets.EMPTY_SET : constants;
    }

    public String getClassName() {
        return className;
    }

    public Set<String> getPrivateClassDependencies() {
        return privateClassDependencies;

    ) {
        DirCacheReference dirCacheReference = dirCaches.get(cacheDir);
        if (dirCacheReference == null) {
            ReferencablePersistentCache cache;
            if (!properties.isEmpty() || initializer != null) {
                Consumer<? super PersistentCache> initAction = initializer != null ? initializer : __ -> {};