public interface ObjectConnectionBuilder {
    /**
     * Creates a transmitter for outgoing messages on the given type. The returned object is thread-safe.
     *
     * <p>Method invocations on the transmitter object are dispatched asynchronously to a corresponding handler in the peer. Method invocations are
     * called on the handler in the same order that they were called on the transmitter object.</p>
     *
     * @param type The type

TextWidth field to 20:

	{"TextWidth": 20}
	-- input --
	Package gob manages streams of gobs - binary values exchanged between an
	Encoder (transmitter) and a Decoder (receiver).
	-- text --
	Package gob
	manages streams
	of gobs - binary
	values exchanged
	between an Encoder
	(transmitter) and a

        e.message == "Cannot add incoming message handler after connection established."

        cleanup:
        connection?.stop()
        connectionBuilder?.stop()
    }

    def "cannot create outgoing message transmitter on established connections"() {
        def connection = new TestConnection()

        given:
        connectCompletion.create(_) >> connection

        when:
        connectionBuilder.connect()

    }

    @Override
    public <T> T addOutgoing(Class<T> type) {
        if (connection != null) {
            throw new GradleException("Cannot add outgoing message transmitter after connection established.");
        }
        methodParamClassLoaders.add(type.getClassLoader());

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package gob manages streams of gobs - binary values exchanged between an
[Encoder] (transmitter) and a [Decoder] (receiver). A typical use is transporting
arguments and results of remote procedure calls (RPCs) such as those provided by
[net/rpc].

		if err := w.SetWriteDeadline(deadline); err != nil {
			t.Fatalf("SetWriteDeadline(%v): %v", deadline, err)
		}
		var n int64
		var err error
		for {
			var dn int
			dn, err = w.Write([]byte("TIMEOUT TRANSMITTER"))
			n += int64(dn)
			if err != nil {
				break
			}
		}
		t1 := time.Now()
		// Inv: err != nil
		if !isDeadlineExceeded(err) {

		if err := c.SetWriteDeadline(deadline); err != nil {
			t.Fatalf("SetWriteDeadline(%v): %v", deadline, err)
		}
		var n int64
		var err error
		for {
			var dn int
			dn, err = c.Write([]byte("TIMEOUT TRANSMITTER"))
			n += int64(dn)
			if err != nil {
				break
			}
		}
		t1 := time.Now()
		// Inv: err != nil
		if !err.(Error).Timeout() {
			t.Fatalf("Write did not return (any, timeout): (%d, %v)", n, err)