assertTrue(result.hasFailure());
        assertEquals(3, result.getFailures().size());
    }

    @Test
    public void test_hasFailure() throws Exception {
        SuggestWriterResult result = new SuggestWriterResult();

        assertFalse(result.hasFailure());

        result.addFailure(new Exception("Test"));

        assertTrue(result.hasFailure());
    }

    @Test

        SuggestWriterResult result =
                writer.write(runner.client(), suggester.settings(), suggester.getIndex(), new SuggestItem[] { item }, false);

        assertNotNull(result);
        assertFalse(result.hasFailure());

        runner.refresh();

        GetResponse getResponse =
                runner.client().prepareGet().setIndex(suggester.getIndex()).setId(item.getId()).get(TimeValue.timeValueSeconds(30));

  internal var isDuplex: Boolean = false
    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection
    get() = codec.carrier as? RealConnection ?: error("no connection for CONNECT tunnels")

  internal val isCoalescedConnection: Boolean

        exchange.finishRequest()
      }
    } catch (e: IOException) {
      if (e is ConnectionShutdownException) {
        throw e // No request was sent so there's no response to read.
      }
      if (!exchange.hasFailure) {
        throw e // Don't attempt to read the response; we failed to send the request.
      }
      sendRequestException = e
    }

    try {
      if (responseBuilder == null) {

    }

    if (closeExchange) {
      exchange?.detachWithViolence()
    }

    interceptorScopedExchange = null
  }

  fun retryAfterFailure(): Boolean =
    exchange?.hasFailure == true &&
      exchangeFinder!!.routePlanner.hasNext(exchange?.connection)

  /**
   * Returns a string that describes this call. Doesn't include a full URL as that might contain
   * sensitive information.

                final SuggestWriterResult result =
                        suggestWriter.write(client, settings, index, updateItems.toArray(new SuggestItem[updateItems.size()]), false);
                if (result.hasFailure()) {
                    throw new SuggestIndexException(result.getFailures().get(0));
                }

                response = client.prepareSearchScroll(scrollId).execute().actionGet(settings.getSearchTimeout());

            }
        }

        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 OpenSearchAccessException(bulkResponse.buildFailureMessage());
                }

                final String sid = scrollId;

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

        when(mockBulkBuilder.execute()).thenReturn(mockBulkFuture);
        when(mockBulkFuture.actionGet(anyLong(), any(TimeUnit.class))).thenReturn(mockBulkResponse);
        when(mockBulkResponse.hasFailures()).thenReturn(false);

        // Setup clear scroll
        when(mockClient.prepareClearScroll()).thenReturn(mockClearScrollBuilder);