return -1;
                        }
                        int toRead = Math.min(buffer.length, remaining);
                        System.arraycopy(includeContent, index[0], buffer, 0, toRead);
                        index[0] += toRead;
                        return toRead;
                    });

				currentPartBytes := v - partOffset
				currentPartDareBytes := v - partDarePkgOffset
				if currentPartBytes < toRead {
					toRead -= currentPartBytes
					l += getEncSize(currentPartDareBytes)
				} else {
					// current part has the last
					// byte required
					lbPartOffset := partOffset + toRead - 1

					// round up the lbPartOffset
					// to the end of the
					// corresponding DARE package

     * @throws IOException if an I/O error occurs
     */
    protected <T extends Response> long doSend(final Request request, final T response, final Set<RequestParam> params, final long timeout)
            throws IOException {
        final long firstKey = prepareRequests(request, response, params, timeout);
        doSend(request);
        return firstKey;
    }

    /**
     * @param request
     * @param response

    /**
     * Sends a request to the remote endpoint.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSend(Request request) throws IOException;

    /**
     * Receives a response from the remote endpoint.
     *
     * @param response the response object to populate
     * @throws IOException if an I/O error occurs

            json={
                "id": 9000,
                "name": "Dead Pond",
                "age": 30,
                "secret_name": "Dive Wilson",
            },
        )
        assert response.status_code == 200, response.text
        assert response.json() == snapshot(
            {"age": 30, "id": IsInt(), "name": "Dead Pond"}
        )
        assert response.json()["id"] != 9000, (

   *
   * @return the source of this event.
   */
  public Object getSource() {
    return source;
  }

  /**
   * Returns the wrapped, 'dead' event, which the system was unable to deliver to any registered
   * subscriber.
   *
   * @return the 'dead' event that could not be delivered.
   */
  public Object getEvent() {
    return event;
  }

  @Override
  public String toString() {

      source: Buffer,
      byteCount: Long,
    ) {
      val toRead = minOf(remainingByteCount, byteCount)
      if (toRead > 0L) {
        source.read(buffer, toRead)
      }
      val toSkip = byteCount - toRead
      if (toSkip > 0L) {
        source.skip(toSkip)
      }
      remainingByteCount -= toRead
      receivedByteCount += byteCount
    }

    @Throws(IOException::class)

            json={
                "id": 999,
                "name": "Dead Pond",
                "age": 30,
                "secret_name": "Dive Wilson",
            },
        )
        assert response.status_code == 200, response.text
        assert response.json() == snapshot(
            {"age": 30, "secret_name": "Dive Wilson", "id": 999, "name": "Dead Pond"}
        )

        # Read a hero

            }
        """
    }

    def "finds broken section links"() {
        given:
        sampleDoc << """
=== Dead Section Links
This section doesn't exist: <<missing_section>>
Also see this one, which is another dead link: <<other_missing_section>>
        """

        and:
        releaseNotes << """
Nothing to write about
        """

        and:

            if (recvException != null) {
                throw recvException;
            }
            return peekedKey;
        }

        @Override
        protected void doSend(Request request) throws IOException {
            if (sendException != null) {
                throw sendException;
            }
        }

        @Override