if (result.getException() != null) {
            throw map(result, result.getException());
        }
        if (result.getFailure() != null) {
            throw map(result, (RuntimeException) payloadSerializer.deserialize(result.getFailure()));
        }
    }

    private RuntimeException map(BuildActionResult result, RuntimeException exception) {

            getRequested() >> selector
            getFromVariant() >> id(from)
            getSelected() >> id(selected)
            getSelectedVariant() >> id(selected)
            getFailure() >> failure
        }
    }

    private Long id(String module) {
        return module.hashCode()
    }

    class DummyModuleVersionSelection implements ResolvedGraphComponent {

            case Unknown:
            case Missing:
                result.noMatchFound();
                break;
            case Failed:
                result.failed(metaDataResult.getFailure());
                break;
            default:
                throw new IllegalStateException("Unexpected meta-data resolution result.");
        }
    }

            getId() >> artifactId
        }

        def file = new File("local")
        def result = Stub(BuildableArtifactFileResolveResult) {
            getFile() >> file
            getFailure() >> null
        }

        def descriptorHash = Hashing.sha1().hashString("Hello")
        def moduleSource = Stub(ModuleDescriptorHashModuleSource) {
            getDescriptorHash() >> descriptorHash
        }

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

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

	public final fun getBody ()Lokio/Buffer;
	public final fun getBodySize ()J
	public final fun getChunkSizes ()Ljava/util/List;
	public final fun getFailure ()Ljava/io/IOException;
	public final fun getHandshake ()Lokhttp3/Handshake;
	public final fun getHeader (Ljava/lang/String;)Ljava/lang/String;
	public final fun getHeaders ()Lokhttp3/Headers;

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

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