"ConnectionReleased",
    )
  }

  @Test
  @Throws(IOException::class)
  fun successfulEmptyH2CallEventSequence() {
    enableTls()
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    assertSuccessfulEventOrder()
  }

  @Test
  @Throws(IOException::class)
  fun multipleDnsLookupsForSingleCall() {
    server.enqueue(

package okhttp3.internal.connection

import java.io.IOException

/** Attempt routes one at a time until one connects. */
internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {

 * Call call = client.newCall(request);
 * call.enqueue(new Callback() {
 *   public void onResponse(Call call, Response response) throws IOException {
 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *

      assertThat(response.peekTrailers()).isNull()
      assertFailsWith<IOException> {
        source.readUtf8()
      }
      try {
        assertThat(response.peekTrailers()).isNull() // Okay. This is what HTTP/1 does.
      } catch (_: IOException) {
        // Also okay. This is what HTTP/2 does.
      }
      assertFailsWith<IOException> {
        response.trailers()
      }
    }
  }

  @Test

 * limitations under the License.
 */
package okhttp3.guide;

import java.io.IOException;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class GetExample {
  final OkHttpClient client = new OkHttpClient();

  String run(String url) throws IOException {
    Request request = new Request.Builder()
        .url(url)
        .build();

  // Guarded by this.
  override lateinit var bytes: ByteString
  override lateinit var exceptionBytes: ByteString

  private var readFailure: IOException? = null

  @Throws(IOException::class)
  private fun readTheList() {
    var publicSuffixListBytes: ByteString?
    var publicSuffixExceptionListBytes: ByteString?

    try {
      listSource().buffer().use { bufferedSource ->

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          e.printStackTrace()
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.use {
            if (!response.isSuccessful) throw IOException("Unexpected code $response")

            for ((name, value) in response.headers) {

   */
  @Throws(IOException::class)
  public fun start(
    inetAddress: InetAddress,
    port: Int,
  ) {
    start(InetSocketAddress(inetAddress, port))
  }

  /**
   * Starts the server and binds to the given socket address.
   *
   * @param socketAddress the socket address to bind the server on
   */
  @Synchronized
  @Throws(IOException::class)

            }
        } catch (XMLStreamException | IOException e) {
            throw new PlexusConfigurationException(e.getMessage(), e);
        }
    }

    private static BufferedInputStream reset(StreamSupplier inputSupplier, BufferedInputStream bis) throws IOException {
        try {
            bis.reset();
            return bis;
        } catch (IOException e) {

          @Override
          public InputStream openStream() throws IOException {
            if (counter[0]++ != 0) {
              throw new IllegalStateException("More than one source open");
            }
            return new FilterInputStream(source.openStream()) {
              @Override
              public void close() throws IOException {
                super.close();
                counter[0]--;
              }