*
   * <p>returns a list containing six lists in the following order:
   *
   * <ul>
   *   <li>{@code ImmutableList.of(1, "A")}
   *   <li>{@code ImmutableList.of(1, "B")}
   *   <li>{@code ImmutableList.of(1, "C")}
   *   <li>{@code ImmutableList.of(2, "A")}
   *   <li>{@code ImmutableList.of(2, "B")}
   *   <li>{@code ImmutableList.of(2, "C")}
   * </ul>
   *

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

   * }
   *
   * <p>For <i>small</i> immutable maps, the {@code ImmutableMap.of()} methods are even more
   * convenient.
   *
   * <p>By default, a {@code Builder} will generate maps that iterate over entries in the order they
   * were inserted into the builder, equivalently to {@code LinkedHashMap}. For example, in the
   * above example, {@code WORD_TO_INT.entrySet()} is guaranteed to iterate over the entries in the

    }
  }

  override fun onClosing(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosing $code", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosing(webSocket, code, reason)
    } else {
      events.add(Closing(code, reason))
    }
  }

  override fun onClosed(

   * {@code put()} or {@code putAll()}, or {@code setValue()} on its entries.
   *
   * <p>In contrast, the maps returned by {@code rowMap().get()} have the same behavior as those
   * returned by {@link #row}. Those maps may support {@code setValue()}, {@code put()}, and {@code
   * putAll()}.
   *

 * that, whenever possible, it is strongly preferred to modify those libraries to return {@code
 * ListenableFuture} directly.
 *
 * <p>For interoperability between {@code ListenableFuture} and <b>{@code CompletableFuture}</b>,
 * consider <a href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.
 *
 * @author Sven Mawson
 * @since 10.0 (replacing {@code Futures.makeListenable}, which existed in 1.0)
 */
@J2ktIncompatible

    }

    @ParameterizedTest(name = "Known code {0} maps to message")
    @MethodSource("knownCodeMessagePairs")
    void lookup_returns_expected_message_for_known_codes(int code, String expectedMessage) {
        // Valid inputs: each known code must map to its documented message
        assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest

    awaitingPong = false
  }

  override fun onReadClose(
    code: Int,
    reason: String,
  ) {
    require(code != -1)

    synchronized(this) {
      check(receivedCloseCode == -1) { "already closed" }
      receivedCloseCode = code
      receivedCloseReason = reason
    }

    listener.onClosing(this, code, reason)
  }

        .Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")
        println("Response 1 network response:  ${it.networkResponse}")