* or all lines have been read and returning the result produced by the processor. Does not close
   * {@code readable}. Note that this method may not fully consume the contents of {@code readable}
   * if the processor stops processing early.
   *
   * <p><b>Users who can use {@code Stream}:</b> If your input is a {@link Reader}, consider

                        + consumed);
            }
            dr.pathConsumed = consumed;
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Node " + ref.getNode() + " path " + reqPath + " remain " + reqPath.substring(consumed) + " path consumed "
                        + consumed);
            }

    timeout.setDelegate(Timeout.NONE)
    oldDelegate.clearDeadline()
    oldDelegate.clearTimeout()
  }

  /**
   * The response body from a CONNECT should be empty, but if it is not then we should consume it
   * before proceeding.
   */
  fun skipConnectBody(response: Response) {
    val contentLength = response.headersContentLength()
    if (contentLength == -1L) return

    delayBeforeTrailers(Protocol.HTTP_1_1)
  }

  @Test
  fun delayBeforeTrailersHttp2() {
    trailers(Protocol.HTTP_2)
  }

  /** Confirm the client will block if necessary to consume trailers. */
  private fun delayBeforeTrailers(protocol: Protocol) {
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .trailers(headersOf("t1", "v2"))

                buffer[i] = (byte) (i % 256);
            }

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            // Should only consume 12 bytes
            assertEquals(12, bytesDecoded);
            assertEquals(15, response.getChunksWritten());
            assertEquals(16384, response.getChunkBytesWritten());

        // Act
        assertTrue(it.hasNext());
        assertEquals("one", it.next().getName()); // consume initial
        // Next call should handle CIFSException and close iterator
        assertFalse(it.hasNext()); // After error, hasNext should return false

        // Assert
        verify(tree, times(1)).release();

   *   -X PUT \
   *   -H 'Authorization: Bearer token' \
   *   --data '{\"key\":\"value\"}'
   * ```
   *
   * **Note:** This will consume the request body. This may have side effects if the [RequestBody]
   * is streaming or can be consumed only once.
   */
  @JvmOverloads
  fun toCurl(includeBody: Boolean = true): String =
    buildString {
      append("curl ${url.toString().shellEscape()}")

        when(dr.getServer()).thenReturn("dfs-server");
        when(dr.getShare()).thenReturn("dfs-share");
        when(dr.getPath()).thenReturn("dfs/path");
        when(dr.getPathConsumed()).thenReturn(2); // consume leading \\ from UNC

        String newUnc = l.handleDFSReferral(dr, "\\req\\");
        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes

   * @since 33.4.0 (but since 22.0 in the JRE flavor)
   */
  /*
   * We have to rely on users not to call this without library desugaring, as NewApi won't flag
   * Consumer creation.
   */
  @IgnoreJRERequirement
  public void forEachLine(Consumer<? super String> action) throws IOException {
    try (Stream<String> lines = lines()) {
      // The lines should be ordered regardless in most cases, but use forEachOrdered to be sure

 *       block indefinitely or fail if the source creates an infinite reader.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> reader will consume or otherwise alter the
 *       source as they are read from it. A source that provides such readers will not be reusable,
 *       and operations that read from the stream (including {@link #length()}, in some