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

import org.gradle.internal.dispatch.Receive;

/**
 * <p>A messaging endpoint which allows push-style dispatch and pull-style receive.
 *
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>

        )

        // now we expect to receive the most recent request since the last request that got a response,
        // that's the last request in our list of pending tasks
        val (reqLast, asyncRespLast) = pendingTasks.last()
        assertThat(
            pendingRequest.receive(),
            sameInstance(reqLast)
        )

        // submit the second (and last) response

        } finally {
            lock.unlock();
        }
    }

    @Override
    public T receive() {
        //in case one wants to synchronize this method,
        //bear in mind that it is blocking so it cannot share the same lock as others
        T result = delegate.receive();
        LOGGER.debug("thread {}: received {}", Thread.currentThread().getId(), result == null ? "null" : result.getClass());
        return result;
    }

            }
        }
    }

    @Override
    @Nullable
    public Message receive() throws DaemonConnectionException {
        try {
            return connection.receive();
        } catch (MessageIOException e) {
            LOG.debug("Problem receiving message to the daemon. Performing 'on failure' operation...");

			}
		}

		// Wait for updates to be available from signal sender.
	Receive:
		for {
			switch sig.state.Load() {
			default:
				throw("signal_recv: inconsistent state")
			case sigIdle:
				if sig.state.CompareAndSwap(sigIdle, sigReceiving) {
					if GOOS == "darwin" || GOOS == "ios" {
						sigNoteSleep(&sig.note)
						break Receive
					}
					notetsleepg(&sig.note, -1)
					noteclear(&sig.note)

	// Set up channel on which to send signal notifications.
	// We must use a buffered channel or risk missing the signal
	// if we're not ready to receive when the signal is sent.
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	// Block until a signal is received.
	s := <-c
	fmt.Println("Got signal:", s)
}

func ExampleNotify_allSignals() {
	// Set up channel on which to send signal notifications.

	b7 = -b0 /* ERROR "not defined" */
	b8 = ^b0 /* ERROR "not defined" */
	b9 = *b0 /* ERROR "cannot indirect" */
	b10 = &true /* ERROR "cannot take address" */
	b11 = &b0
	b12 = <-b0 /* ERROR "cannot receive" */
	b13 = & & /* ERROR "cannot take address" */ b0
	b14 = ~ /* ERROR "cannot use ~ outside of interface or type constraint" */ b0

	// byte
	_ = byte(0)
	_ = byte(- /* ERROR "overflows" */ 1)

func (v Vector) MarshalBinary() ([]byte, error) {
	// A simple encoding: plain text.
	var b bytes.Buffer
	fmt.Fprintln(&b, v.x, v.y, v.z)
	return b.Bytes(), nil
}

// UnmarshalBinary modifies the receiver so it must take a pointer receiver.
func (v *Vector) UnmarshalBinary(data []byte) error {
	// A simple encoding: plain text.
	b := bytes.NewBuffer(data)
	_, err := fmt.Fscanln(b, &v.x, &v.y, &v.z)
	return err
}