)

	msgs := diag.Messages{firstMsg, secondMsg}
	output, _ := Print(msgs, YAMLFormat, false)

	expectedOutput := `- code: B1
  documentationUrl: ` + url.ConfigAnalysis + `/b1/
  level: Error
  message: 'Explosion accident: the bubble is too big'
  origin: SoapBubble
- code: C1
  documentationUrl: ` + url.ConfigAnalysis + `/c1/
  level: Warning
  message: 'Collapse danger: the castle is too old'

   * messages.
   */
  open fun onOpen(
    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(

        result.logLevel == LogLevel.LIFECYCLE
        result.message == MESSAGE
        result.throwable.getClass() == event.throwable.getClass()
        result.throwable.message == event.throwable.message
        result.throwable.stackTrace == event.throwable.stackTrace
        result.buildOperationId == new OperationIdentifier(42L)
    }

    def "can serialize LogEvent messages"() {
        when:

		json.Unmarshal([]byte(srv.messages[0]), &got[0])
		json.Unmarshal([]byte(srv.messages[1]), &got[1])
		if !reflect.DeepEqual(got, want) {
			t.Errorf("received log messages, got %v want %v", got, want)
		}
	}

	{
		t.Log("test sending log with specified time")

		// Clean up all the mssages, and log again. Check that buffer is cleaned up properly.
		srv.messages = make([]string, 0)

        then:
        result*.message == ["incoming1", "incoming2"]
    }

    static class TestConnection implements RemoteConnection<Message> {
        private final def lock = new Object()
        private final def endInput = new Received("end")
        private final def receiveQueue = new LinkedList<Message>()

        @Override
        void dispatch(Message message) throws MessageIOException {

        def expectedDeprecations = messages
            .findAll { problem -> problem.severity == WARNING }
        def expectedFailures = messages
            .findAll { problem -> problem.severity == ERROR }

        expectedDeprecations.forEach { warning ->
            expectThatExecutionOptimizationDisabledWarningIsDisplayed(executer, warning.message, warning.id, warning.section)
        }

    }

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

absl::StatusOr<std::vector<std::string>> ListDirectory(
    absl::string_view directory);

template <class MessageT>
absl::StatusOr<MessageT> ReadBinaryProto(const std::string& binary_file_path) {
  MessageT message;
  TF_RETURN_IF_ERROR(
      tsl::ReadBinaryProto(tsl::Env::Default(), binary_file_path, &message));
  return message;
}

}  // namespace stablehlo::quantization::io

    }

    /**
     * A simple implementation which always logs messages of level WARN
     * according to the format outlined above.
     */
    @Override
    public void warn(String msg) {
        super.warn(msg);
        logLevelRecorder.record(Level.WARN);
    }

    /**
     * Perform single parameter substitution before logging the message of level
     * WARN according to the format outlined above.
     */

        // waiting endpoint, even if there are multiple waiting to do work
        EndPointQueue selected = waiting.isEmpty() ? null : waiting.get(0);
        while (!queue.isEmpty()) {
            InterHubMessage message = queue.peekFirst();
            switch (message.getDelivery()) {