<developer>
      <id>cpovirk</id>
      <name>Chris Povirk</name>
      <email>******@****.***</email>
    </developer>
  </developers>

  <scm>
    <connection>scm:git:https://github.com/google/guava.git</connection>
    <developerConnection>scm:git:******@****.***:google/guava.git</developerConnection>
    <url>https://github.com/google/guava</url>
  </scm>

  <issueManagement>

     * @param url The URL to set.
     */
    public void setUrl(final String url) {
        this.url = url;
    }

    /**
     * Sets the connection timeout.
     * @param connectionTimeout The connection timeout in milliseconds.
     */
    public void setConnectionTimeout(final Integer connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    /**

		xhttp.DrainBody(respBody)
		return !isNetworkError(err)
	}
	var gridConn atomic.Pointer[grid.Connection]

	return &peerRESTClient{
		host: peer, restClient: restClient, gridHost: gridHost,
		gridConn: func() *grid.Connection {
			// Lazy initialization of grid connection.
			// When we create this peer client, the grid connection is likely not yet initialized.
			if gridHost == "" {

    /** Active error in the name service */
    public static final int ACT_ERR = 0x6;
    /** Name in conflict error */
    public static final int CFT_ERR = 0x7;

    // session service error codes
    /** Connection refused by the remote host */
    public static final int CONNECTION_REFUSED = -1;
    /** Not listening on the called name */
    public static final int NOT_LISTENING_CALLED = 0x80;

    /**
     * Default constructor for InputSource.
     */
    public InputSource() {}

    /**
     * Creates a new InputSource from an API model InputSource.
     * This constructor is used for converting between the API model and the compat model.
     *
     * @param source the API model InputSource to convert from
     */
    public InputSource(org.apache.maven.api.model.InputSource source) {

      val logHeaders = logBody || level == Level.HEADERS

      val requestBody = request.body

      val connection = chain.connection()
      var requestStartMessage =
        ("--> ${request.method} ${redactUrl(request.url)}${if (connection != null) " " + connection.protocol() else ""}")
      if (!logHeaders && requestBody != null) {
        requestStartMessage += " (${requestBody.contentLength()}-byte body)"

import java.util.concurrent.FutureTask
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit
import mockwebserver3.SocketHandler
import okhttp3.internal.connection.BufferedSocket
import okhttp3.internal.connection.asBufferedSocket
import okio.Socket
import okio.utf8Size

private typealias Action = (BufferedSocket) -> Unit

/**

    client.processNextFrame() // Read server closing, close connection.
    taskFaker.runTasks()
    client.listener.assertClosing(1000, "Goodbye!")
    client.webSocket!!.finishReader()
    taskFaker.runTasks()
    assertThat(client.closed).isTrue()

    // Server and client both finished closing, connection is closed.
    server.listener.assertClosed(1000, "Hello!")

   *    can successfully complete the cache entry.
   *
   *  * Throttle the response. The HTTP/1 connection pool will attempt to read the entire response
   *    body so that it can pool the connection.
   */
  private fun trailersWithClientPrematureClose(protocol: Protocol) {
    val halfResponseBody = "a".repeat(OKHTTP_CLIENT_WINDOW_SIZE)
    enableProtocol(protocol)

  }

  final NetworkConnections<N, E> checkedConnections(N node) {
    NetworkConnections<N, E> connections = nodeConnections.get(node);
    if (connections == null) {
      checkNotNull(node);
      throw new IllegalArgumentException(String.format(NODE_NOT_IN_GRAPH, node));
    }
    return connections;
  }

  final N checkedReferenceNode(E edge) {
    N referenceNode = edgeToReferenceNode.get(edge);