/**
 * A general purpose sink for a stream of messages.
 *
 * <p>Implementations are not required to be thread-safe.
 */
public interface Dispatch<T> {
    /**
     * Dispatches the next message. Blocks until the messages has been accepted but generally does not wait for the
     * message to be processed. Delivery guarantees are implementation specific.
     *
     * @param message The message.
     */
    void dispatch(T message);

        incoming.take(messages)

        then:
        messages.size() == 1
        messages == [sentinel]

        when:
        messages = []
        connection.dispatchFinished()
        connection.receiveFinished()
        incoming.take(messages)

        then:
        messages.size() == 2
        messages[0] instanceof RejectedMessage
        messages[0].payload == "payload"
        messages[1] instanceof EndOfStream

    // Read-only property calculated from the greeting
    @Internal
    val message: Provider<String> = greeting.map { it + " from Gradle" }

    @TaskAction
    fun printMessage() {
        logger.quiet(message.get())
    }
}

// Create the project extension
val messages = project.extensions.create<MessageExtension>("messages")

// Create the greeting task
tasks.register<Greeting>("greeting") {

	)

	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'

// client and ignore messages sent to the server. The received messages are
// the exact bytes written to the stream. Zero byte messages are possible.
const binaryWebSocketProtocol = "binary.k8s.io"

// The WebSocket subprotocol "base64.binary.k8s.io" will only send messages to the
// client and ignore messages sent to the server. The received messages are

 * a greeting. The greeting is composed of a message and a suffix. The message is compiled into a support
 * library. The suffix is compiled directly into the processor. This makes it easy to test different incremental
 * change scenarios. The message can also be provided with the -Amessage processor argument.
 */
@CompileStatic
class HelperProcessorFixture extends AnnotationProcessorFixture {
    String message = "greetings"
    boolean writeResources

            description.appendText("was a ProjectBuildingResult with messages ");
            String messages = r.getProblems().stream()
                    .map(ModelProblem::getMessage)
                    .map(m -> "\"" + m + "\"" + System.lineSeparator())
                    .collect(joining(", "));
            description.appendText(messages);
        }
    }

   * 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)