super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(
        String message, String a1, String a2, String a3) {
      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(String message, Throwable antecedent) {
      super(message);
      this.antecedent = antecedent;
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(

      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(
        String message, String a1, String a2, String a3) {
      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(String message, Throwable antecedent) {
      super(message);
      this.antecedent = antecedent;
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(

            () ->
                getChecked(
                    FAILED_FUTURE_CHECKED_EXCEPTION, ExceptionWithoutThrowableConstructor.class));
    assertThat(expected).hasMessageThat().contains("mymessage");
    assertThat(expected).hasCauseThat().isEqualTo(CHECKED_EXCEPTION);
  }

  public void testPrefersConstructorWithThrowableParameter() {
    ExceptionWithManyConstructorsButOnlyOneThrowable exception =

    }
  }

  override fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
    Platform.get().log("[WS $name] onMessage", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onMessage(webSocket, bytes)
    } else {
      events.add(Message(bytes = bytes))
    }
  }

  override fun onMessage(

    webSocket.close(1000, "Goodbye, World!");
  }

  @Override public void onMessage(WebSocket webSocket, String text) {
    System.out.println("MESSAGE: " + text);
  }

  @Override public void onMessage(WebSocket webSocket, ByteString bytes) {
    System.out.println("MESSAGE: " + bytes.hex());
  }

  @Override public void onClosing(WebSocket webSocket, int code, String reason) {

    webSocket: WebSocket,
    response: Response,
  ) {
  }

  /** Invoked when a text (type `0x1`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
  }

  /** Invoked when a binary (type `0x2`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
  }

  /**

      }
    }

    try {
      if (pong != null) {
        writer!!.writePong(pong)
      } else if (messageOrClose is Message) {
        val message = messageOrClose
        writer!!.writeMessageFrame(message.formatOpcode, message.data)
        synchronized(this) {
          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose

    val message: ByteString = ByteString.of(*ByteArray(1024 * 1024))
    var messageCount: Long = 0
    while (true) {
      val success = webSocket.send(message)
      if (!success) break
      messageCount++
      val queueSize = webSocket.queueSize()
      assertThat(queueSize).isBetween(0L, messageCount * message.size)
      // Expect to fail before enqueueing 32 MiB.

        override fun onOpen(
          webSocket: WebSocket,
          response: Response,
        ) = TODO()

        override fun onMessage(
          webSocket: WebSocket,
          text: String,
        ) = TODO()

        override fun onMessage(
          webSocket: WebSocket,
          bytes: ByteString,
        ) = TODO()

        override fun onClosing(

        // Test constructor with message only
        String message = "SSO login failed";
        SsoLoginException exception = new SsoLoginException(message);

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

    public void test_constructor_withMessageAndCause() {
        // Test constructor with message and cause