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

        public void visit(ArtifactVisitor visitor) {
            if (visitor.requireArtifactFiles() && !artifact.getFileSource().getValue().isSuccessful()) {
                visitor.visitFailure(artifact.getFileSource().getValue().getFailure().get());
            } else {
                visitor.visitArtifact(variantName, variantAttributes, capabilities, artifact);
                visitor.endVisitCollection(FileCollectionInternal.OTHER);
            }

    }

    private TaskRequiredServices emptyTaskRequiredServices() {
        Stub(TaskRequiredServices)
    }

    void failure(TaskInternal task, final RuntimeException failure) {
        task.state.getFailure() >> failure
        task.state.rethrowFailure() >> { throw failure }
    }

    private static class MockLock implements ResourceLock {
        final Thread owner = Thread.currentThread()