*
   * <ol>
   *   <li>Use sendfile(2) or equivalent. Requires that both the input channel and the output
   *       channel have their own file descriptors. Generally this only happens when both channels
   *       are files or sockets. This performs zero copies - the bytes never enter userspace.
   *   <li>Use mmap(2) or equivalent. Requires that either the input channel or the output channel

            writer: DerWriter,
            value: String,
          ) = writer.writeUtf8(value)
        },
    )

  /**
   * Based on International Alphabet No. 5. Note that there are bytes that IA5 and US-ASCII
   * disagree on interpretation.
   *
   * TODO(jwilson): constrain to IA5 characters.
   */
  val IA5_STRING =
    BasicDerAdapter(
      name = "IA5 STRING",

    assertThat(client.connectionPool.connectionCount()).isEqualTo(1)
  }

  /**
   * This is an extraordinary test case. Here's what it's trying to simulate.
   * - 2 requests happen concurrently to a host that can be coalesced onto a single connection.
   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".

   * has not added {@link AnnotatedType}. That means that we cannot implement that interface in
   * source code in a way that will compile on both Java and Android. If we include the {@code
   * getAnnotatedBounds()} method, then its return type means it won't compile on Android, while if
   * we don't include the method, then the compiler will complain that an abstract method is

     * field should be used for calculating that. This would likely be zero
     * but an implemantation that encorporates the transport header(for
     * efficiency) might use a different initial bufferIndex. For example,
     * to eliminate copying data when writing NbtSession data one might
     * manage that 4 byte header specifically and therefore the initial

 * that you implement a {@link Funnel}{@code <T>} to specify how to "feed" data from that object
 * into the function. (See {@linkplain Hasher#putObject an example} of this.)
 *
 * <p><b>Compatibility note:</b> Throughout this API, multibyte values are always interpreted in
 * <i>little-endian</i> order. That is, hashing the byte array {@code {0x01, 0x02, 0x03, 0x04}} is

      HashCode that = (HashCode) object;
      return bits() == that.bits() && equalsSameBits(that);
    }
    return false;
  }

  /**
   * Returns a "Java hash code" for this {@code HashCode} instance; this is well-defined (so, for
   * example, you can safely put {@code HashCode} instances into a {@code HashSet}) but is otherwise
   * probably not what you want to use.
   */
  @Override

 * that you implement a {@link Funnel}{@code <T>} to specify how to "feed" data from that object
 * into the function. (See {@linkplain Hasher#putObject an example} of this.)
 *
 * <p><b>Compatibility note:</b> Throughout this API, multibyte values are always interpreted in
 * <i>little-endian</i> order. That is, hashing the byte array {@code {0x01, 0x02, 0x03, 0x04}} is

 * stores information-per-URL will need to either canonicalize manually, or suffer unnecessary
 * redundancy for such URLs.
 *
 * Because they don't attempt canonical form, these classes are surprisingly difficult to use
 * securely. Suppose you're building a webservice that checks that incoming paths are prefixed

     * be retrieved with the Node Status request.
     *
     * The degree of state that an NbtAddress has is dependant on how it was
     * created and what is required of it. The second degree of state is the
     * most common. This is the state information that would be retrieved from
     * WINS for example. Natrually it is not practical for every NbtAddress