String message = "No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories." +
                (hasFailures() ? " " + failureMessage() : "");

            String[] resolutions = {
                "Learn more about toolchain auto-detection at " + Documentation.userManual("toolchains", "sec:auto_detection").getUrl() + ".",

            void write(OutputStream outputStream);
        }

        class NoResourceToGenerate implements GenerationResult {
        }

        class ResourceFailures implements GenerationResult, HasFailures {
            private final List<FailureInfo> failures;

            public ResourceFailures(List<FailureInfo> failures) {
                this.failures = failures;
            }

            @Override

            }
        }

        final BulkResponse response = bulkRequestBuilder.execute().actionGet(settings.getBulkTimeout());
        final SuggestWriterResult result = new SuggestWriterResult();
        if (response.hasFailures()) {
            for (final BulkItemResponse bulkItemResponses : response.getItems()) {
                if (bulkItemResponses.isFailed()) {

                        builder.add(updateRequest);
                    }

                    return builder.execute();
                });
                if (bulkResponse.hasFailures()) {
                    throw new EsAccessException(bulkResponse.buildFailureMessage());
                }

                final String sid = scrollId;

    }

    protected void flush() {
        if (bulkRequestBuilder != null) {
            final BulkResponse response = bulkRequestBuilder.execute().actionGet(requestTimeout);
            if (response.hasFailures()) {
                logger.warn("Failed to update scores: {}", response.buildFailureMessage());
            }
            bulkRequestBuilder = null;
        }
    }

    public int getPriority() {

                ExecutionResult<Void> result = workController.scheduleAndRunRequestedTasks(null);
                if (!result.getFailures().isEmpty()) {
                    return result.asFailure();
                }
            }
            T model = modelCreator.fromBuildModel(action);
            return ExecutionResult.succeeded(model);
        });
    }

    @Override

            bufferedList.add(target);
            if (bufferedList.size() >= bulkBufferSize) {
                final BulkResponse response = doInsertAll(bufferedList, opType);
                if (response.hasFailures()) {
                    final String failureMessage = buildFailureMessage(response, ignoreAlreadyExists);
                    if (failureMessage.length() > 0) {

            }
        } else if (result instanceof ResourceFailures) {
            printFailures((ResourceFailures) result);
        }
    }

    private void printFailures(HasFailures failure) {
        failure.getFailureDetails().forEach(details -> {
            Optional<ExecutableElement> maybeOriginatingElement =
                    Optional.ofNullable(details.request)

        result.failures.empty
        result.rethrow()

        when:
        result.failure

        then:
        thrown(IllegalArgumentException)

        when:
        result.asFailure()

        then:
        thrown(IllegalArgumentException)
    }

    def "can query successful void result"() {
        def result = ExecutionResult.succeeded()

        expect:

            throwFailure();
            return false;
        }

        @Override
        public ExecutionResult<Void> asResult() {
            return failure.asFailure();
        }

        @Override
        public boolean inStateAndNotTransitioning(T toState) {
            throwFailure();
            return false;
        }

        @Override