() -> {
                    delegate.resolveArtifact(artifact, moduleSources, result);
                    if (result.hasResult()) {
                        ArtifactResolveException failure = result.getFailure();
                        if (!(failure instanceof ArtifactNotFoundException)) {
                            return failure;
                        }
                    }
                    return null;

        }
        return toFailureContainer(((InternalBasicProblemDetailsVersion2) problemDetails).getFailure());
    }

    private static FailureContainer toFailureContainer(@Nullable InternalBasicProblemDetailsVersion3 problemDetails) {
        return toFailureContainer(problemDetails == null ? null : problemDetails.getFailure());
    }

    private static FailureContainer toFailureContainer(@Nullable InternalFailure failure) {

                        Collection<RepositoryAwareVerificationFailure> value = entry.getValue();
                        return value.stream().anyMatch(wrapper -> wrapper.getFailure().isFatal());
                    }).collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));

                return;
            }

            Finished notification = new Finished(finishEvent.getEndTime(), id, parentId, buildOperation.getDetails(), finishEvent.getResult(), finishEvent.getFailure());
            try {
                notificationListener.finished(notification);
            } catch (Throwable e) {

                                StreamFailureMessage streamFailureMessage = (StreamFailureMessage) message;
                                streamFailureHandler.handleStreamFailure(streamFailureMessage.getFailure());
                            } else {
                                throw new IllegalArgumentException(String.format("Don't know how to handle message %s", message));
                            }

        }
    }

    ExecutionResult getResult() {
        return OutputScrapingExecutionResult.from(stdout.toString(), stderr.toString())
    }

    ExecutionFailure getFailure() {
        return OutputScrapingExecutionFailure.from(stdout.toString(), stderr.toString())
    }

    def validateOutput() {

                throw new GradleException("Could not map coordinates for " + unresolved.getAttempted().getDisplayName() + ".", unresolved.getFailure());
            }

            if (dependencyResult.isConstraint()) {
                // Constraints also appear in the graph if they contributed to it.

        this(textOutputFactory, loggingConfiguration, clientMetaData, null);
    }

    public void buildFinished(BuildResult result) {
        Throwable failure = result.getFailure();
        if (failure == null) {
            return;
        }

        execute(failure);
    }

    @Override
    public void execute(@Nonnull Throwable failure) {

        _ * mock.name >> name
        _ * mock.identityPath >> project.identityPath.child(name)
        _ * mock.project >> project
        _ * mock.state >> Stub(TaskStateInternal) {
            getFailure() >> failure
            rethrowFailure() >> { throw failure }
        }
        _ * mock.taskDependencies >> Stub(TaskDependencyInternal)
        _ * mock.lifecycleDependencies >> Stub(TaskDependencyInternal)

        }
    }

    @Test
    public void propagatesGetPropertyException() {
        final RuntimeException failure = new RuntimeException();
        Bean bean = new Bean() {
            String getFailure() {
                throw failure;
            }
        };

        try {
            bean.getProperty("failure");
            fail();
        } catch (Exception e) {