public boolean getExecuting() {
        return executing;
    }

    public void setExecuting(boolean executing) {
        this.executing = executing;
    }

    @Override
    public Throwable getFailure() {
        return failure;
    }

    @Override
    public void rethrowFailure() {
        if (failure != null) {
            throw failure;
        }
    }

    @Override

        // no-op
    }

    @SuppressWarnings("deprecation")
    @Override
    public void buildFinished(BuildResult result) {
        buildProfile.setSuccessful(result.getFailure() == null);
    }

    // ProjectEvaluationListener
    @Override
    public void beforeEvaluate(Project project) {
        long now = clock.getCurrentTime();

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

            return buildPath;
        }

        @Override
        public String getCacheKey() {
            return key.getHashCode();
        }

        @Override
        public Throwable getFailure() {
            return e;
        }

        @Override
        public BuildCacheOperationType getOperationType() {
            return operationType;
        }
    }

        lock.lock();
        try {
            pendingChanges.changesIncorporated();
            if (!pendingChanges.hasRemainingChanges()) {
                Throwable failure = buildResult.getFailure();
                for (RegisteredDeployment deployment : deployments.values()) {
                    deployment.upToDate(failure);
                }
            }
        } finally {
            lock.unlock();

            this.stackTrace = stackTrace;
            this.location = location;
            this.source = source;
        }

        @Nullable
        @Override
        public Failure getFailure() {
            return failure;
        }

        @Nullable
        @Override
        public Throwable getException() {
            return exception;
        }

        @Override

        public DefaultDevelocityPluginResult(@Nullable Throwable buildFailure) {
            this.buildFailure = buildFailure;
        }

        @Nullable
        @Override
        public Throwable getFailure() {
            return buildFailure;
        }

        @Override
        public Collection<Problem> getProblems() {
            return getProblems(buildFailure);
        }

        @Override

                    basicDetails.getDetails(),
                    basicDetails.getLocations(),
                    basicDetails.getSolutions(),
                    basicDetails.getFailure(),
                    basicDetails.getContextualLabel()
                );
            } else {
                throw new UnsupportedOperationException("Unsupported problem details: " + detailsV2.getClass().getName());

            if (listener != null) {
                listener.execute(new BuildResult() {
                    @Nullable
                    @Override
                    public Throwable getFailure() {
                        return buildFailure;
                    }
                });
            }
        }
    }

                        result.getExecutionReasons()
                    );
                    operationContext.setResult(operationResult);
                    result.getExecution().getFailure().ifPresent(operationContext::failed);
                    return result;
                },
                BuildOperationDescriptor
                    .displayName("Execute unit of work")