return super.writeReplace();
        }
      };
    } else {
      return super.createAsList();
    }
  }

  @Override
  public int size() {
    long distance = domain.distance(first(), last());
    return (distance >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) distance + 1;
  }

  @Override
  public boolean contains(@Nullable Object object) {

        keyTail.nextSibling = node;
        node.previousSibling = keyTail;
        keyList.tail = node;
      }
    } else { // non-empty list, insert before nextSibling
      /*
       * requireNonNull is safe as long as callers pass a nextSibling that (a) has the same key and
       * (b) is present in the multimap. (And they do, except maybe in case of concurrent
       * modification, in which case all bets are off.)
       */

 *
 * @see java.io.Serializable
 */
public class RequestHeader implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * The name of the request header.
     */
    private String name;

    /**
     * The value of the request header.
     */
    private String value;

    /**

 * </p>
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = 1L;

    /**
     * Default initial capacity.
     */
    protected static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * Default load factor.
     */

  }

  fun shutdownOutput() {
    javaNetSocket.shutdownOutput()
  }

  /** Sleeps [nanos], throwing if the socket is closed before that period has elapsed. */
  fun sleepWhileOpen(nanos: Long) {
    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")

    }
    return false;
  }

  @Override
  public String toString() {
    return forwardOrder + ".reverse()";
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

        .addHeader("Retry-After", "1")
        .body("You took too long!")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val request = Request(server.url("/"))
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("You took too long!")
  }

  @Test
  fun requestBodyRetransmittedOnClientRequestTimeout() {

     *
     * <p>It is strongly encouraged to use {@link #add(String, long)} instead and give value a
     * readable name.
     *
     * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
     */
    @CanIgnoreReturnValue
    public ToStringHelper addValue(long value) {
      return addUnconditionalHolder(String.valueOf(value));
    }

 */
package org.codelibs.core.exception;

/**
 * Exception while accessing a file.
 *
 * @author shinsuke
 *
 */
public class FileAccessException extends ClRuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * Creates a new {@link FileAccessException} with the specified message code, arguments, and cause.
     *
     * @param messageCode
     *            the message code

 *     throw new CurlException("Error message", cause);
 * </pre>
 *
 * @see RuntimeException
 */
public class CurlException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new CurlException with the specified detail message and cause.
     *