fun connectionPreface() {
    withLock {
      if (closed) throw IOException("closed")
      if (!client) return // Nothing to write; servers don't send connection headers!
      if (logger.isLoggable(FINE)) {
        logger.fine(format(">> CONNECTION ${CONNECTION_PREFACE.hex()}"))
      }
      sink.write(CONNECTION_PREFACE)
      sink.flush()
    }
  }

  /** Applies `peerSettings` and then sends a settings ACK. */

            try {
                logger.fine(() -> ">>> " + method + " " + url);
                final URL u = new URL(url);
                connection = open(u);
                connection.setRequestMethod(method.toString());
                if (headerList != null) {
                    for (final String[] values : headerList) {
                        logger.fine(() -> ">>> " + values[0] + "=" + values[1]);

    @Override
    public boolean isDebugEnabled() {
        return logger.isLoggable(Level.FINE);
    }

    @Override
    public void debug(final String message) {
        logger.logp(Level.FINE, sourceClass, null, message);
    }

    @Override
    public void debug(final String message, final Throwable t) {
        logger.logp(Level.FINE, sourceClass, null, message, t);
    }

    when {
      logger.isLoggable(Level.FINE) -> Throwable(closer) // These are expensive to allocate.
      else -> null
    }

  open fun logCloseableLeak(
    message: String,
    stackTrace: Any?,
  ) {
    var logMessage = message
    if (stackTrace == null) {
      logMessage += " To see where this was allocated, set the OkHttpClient logger level to " +

    Set<Feature<?>> features = copyToSet(getFeatures());
    @SuppressWarnings("rawtypes") // class literals
    List<Class<? extends AbstractTester>> testers = getTesters();

    logger.fine(" Testing: " + name);

    // Split out all the specified sizes.
    Set<Feature<?>> sizesToTest = Helpers.<Feature<?>>copyToSet(CollectionSize.values());
    sizesToTest.retainAll(features);

        .testEquals();
  }

  public void testRequireBracketsForIPv6() {
    // Bracketed IPv6 works fine.
    assertEquals("::1", HostAndPort.fromString("[::1]").requireBracketsForIPv6().getHost());
    assertEquals("::1", HostAndPort.fromString("[::1]:80").requireBracketsForIPv6().getHost());
    // Non-bracketed non-IPv6 works fine.
    assertEquals("x", HostAndPort.fromString("x").requireBracketsForIPv6().getHost());

        .testEquals();
  }

  public void testRequireBracketsForIPv6() {
    // Bracketed IPv6 works fine.
    assertEquals("::1", HostAndPort.fromString("[::1]").requireBracketsForIPv6().getHost());
    assertEquals("::1", HostAndPort.fromString("[::1]:80").requireBracketsForIPv6().getHost());
    // Non-bracketed non-IPv6 works fine.
    assertEquals("x", HostAndPort.fromString("x").requireBracketsForIPv6().getHost());

      }
    }

    return true
  }

  @Throws(IOException::class)
  private fun readEmptyLine(source: BufferedSource) {
    val line = source.readUtf8LineStrict()
    check(line.isEmpty()) { "Expected empty but was: $line" }
  }

  public override fun toString(): String {
    val socketAddress = socketAddress_
    return when {
      closed -> "MockWebServer{closed}"

        }
        if (offset + SIGNATURE_OFFSET + SIGNATURE_LENGTH > data.length) {
            throw new IllegalArgumentException("Signature field exceeds data buffer size");
        }

        // Use fine-grained locking for better concurrency
        this.signingLock.lock();
        try {
            if (this.closed) {
                throw new IllegalStateException("SigningDigest is closed");
            }

          return "stopped()";
        }
      };

  /**
   * A listener for the aggregate state changes of the services that are under management. Users
   * that need to listen to more fine-grained events (such as when each particular {@linkplain
   * Service service} starts, or terminates), should attach {@linkplain Service.Listener service
   * listeners} to each individual service.
   *