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

    }
}


/**
 * 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 {

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new ReportStatus(UUID.randomUUID(), "TOKEN".bytes)
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:
        0 * connection.receive()
        noExceptionThrown()
    }

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new Stop(UUID.randomUUID())
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:
        0 * connection.receive()
        noExceptionThrown()
    }

    def "ignores failed receive"() {
        given:

			expectCorrect:   nil,
			expectIncorrect: nil,
		},
		{
			desc:            "want IPv4 and receive IPv6",
			ipString:        []string{"fd00:20::1"},
			wantIPv6:        false,
			expectCorrect:   nil,
			expectIncorrect: []string{"fd00:20::1"},
		},
		{
			desc:            "want IPv6 and receive IPv4",
			ipString:        []string{"192.168.200.2"},
			wantIPv6:        true,
			expectCorrect:   nil,

        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

        and:
        1 * connector.maybeConnect(daemon2) >>> connection
        _ * connection.daemon >> daemon2
        1 * connection.dispatch({it instanceof StopWhenIdle})
        1 * connection.receive() >> new Success(null)

    ```

The files and form fields will be uploaded as form data and you will receive the files and form fields.

And you can declare some of the files as `bytes` and some as `UploadFile`.

!!! warning