* A source for messages. Implementations do not have to be thread-safe.
 */
public interface Receive<T> {
    /**
     * Blocks until the next message is available. Returns null when the end of the message stream has been reached.
     *
     * @return The next message, or null when the end of the stream has been reached.
     */
    @Nullable
    T receive();

        def result = []
        result << daemonConnection.receive(20, TimeUnit.SECONDS)
        result << daemonConnection.receive(20, TimeUnit.SECONDS)
        result << daemonConnection.receive(20, TimeUnit.SECONDS)
        daemonConnection.stop()

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

    def "receive blocks until message available"() {

        0 * staleAddressDetector._
    }

    def "handles failed receive"() {
        def failure = new FooException()

        given:
        1 * delegate.receive() >> Stub(Message)
        delegate.receive() >> { throw failure }

        when:
        connection.receive()
        connection.receive()

        then:
        def ex = thrown(DaemonConnectionException)

		_ = x

	case cr <- 0: // ERROR "send"
	case x := <-cr: // ok
		_ = x

	case cs <- 0: // ok
	case x := <-cs: // ERROR "receive"
		_ = x
	}

	for _ = range cs { // ERROR "receive"
	}

	for range cs { // ERROR "receive"
	}

	close(c)
	close(cs)
	close(cr) // ERROR "receive"
	close(n)  // ERROR "invalid operation.*non-chan type|must be channel|non-channel"

	{{/*  Blocking or non-blocking again, after the receive. */}}
	{{if .MaybeDefault}}
	default:
		panic("nonblock")
	{{end}}
	{{/*  Dummy send, receive to keep compiler from optimizing select. */}}
	{{if .Maybe}}
	case dummy <- 1:
		panic("dummy send")
	{{end}}
	{{if .Maybe}}
	case <-dummy:
		panic("dummy receive")
	{{end}}
	{{/*  Nil channel send, receive to keep compiler from optimizing select. */}}

    def receive_wrapper(self, receive):
        received = 0

        async def inner():
            nonlocal received
            message = await receive()
            if message["type"] != "http.request":
                return message  # pragma: no cover

            body_len = len(message.get("body", b""))
            received += body_len
            if received > self.max_content_size:

    }
}


/**
 * A convention that applies a nested object access operation (e.g. foo { }).
 */
class NestedObjectAccessConvention(private val nestedObjectAccessRecord: NestedObjectAccessRecord) :
    Convention<NestedObjectAccessRecordConventionReceiver> {
    override fun apply(receiver: NestedObjectAccessRecordConventionReceiver) {
        receiver.receive(nestedObjectAccessRecord)
    }
}

        when:
        communicator.stop()

        then:
        communicator.getPort() == -1
    }

    def "can receive lock id and type"() {
        FileLockPacketPayload receivedPayload

        start {
            def packet = communicator.receive()
            receivedPayload = communicator.decode(packet)
        }

        poll {

package p

// Verify that the "must be receive" error for "case done:" appears
// on the line of the case clause, not the line of the done declaration.

func f(done chan struct{}) {
	select {
	case done: // ERROR "must be receive|expected .*<-.* or .*=|must be send or receive|not used"
	case (chan struct{})(done): // ERROR "must be receive|expected .*<-.* or .*=|must be send or receive"
	}

func _[T any](ch T) {
	<-ch // ERRORx `cannot receive from ch .* \(no core type\)`
}

func _[T C0](ch T) {
	<-ch // ERROR "cannot receive from non-channel ch"
}

func _[T C1](ch T) {
	<-ch
}

func _[T C2](ch T) {
	<-ch
}

func _[T C3](ch T) {
	<-ch // ERRORx `cannot receive from ch .* \(no core type\)`
}

func _[T C4](ch T) {
	<-ch // ERROR "cannot receive from send-only channel"
}