} catch (e: IOException) {
        failConnection(e)
      }
    }
  }

  fun writePing(
    reply: Boolean,
    payload1: Int,
    payload2: Int,
  ) {
    try {
      writer.ping(reply, payload1, payload2)
    } catch (e: IOException) {
      failConnection(e)
    }
  }

  /** For testing: sends a ping and waits for a pong. */

<img src="/img/tutorial/generate-clients/image08.png">

## Benefits

When using the automatically generated clients you would get **autocompletion** for:

* Methods.
* Request payloads in the body, query parameters, etc.
* Response payloads.

You would also have **inline errors** for everything.

	pp := l.allocPayload()
	pp.name = name
	pp.ver = ver
	l.payloads = append(l.payloads, pp)
	l.growExtAttrBitmaps()
	return pi
}

// getPayload returns a pointer to the extSymPayload struct for an
// external symbol if the symbol has a payload. Will panic if the
// symbol in question is bogus (zero or not an external sym).
func (l *Loader) getPayload(i Sym) *extSymPayload {
	if !l.IsExternal(i) {

## Vorteile

Wenn Sie die automatisch generierten Clients verwenden, erhalten Sie **automatische Codevervollständigung** für:

* Methoden.
* Request-Payloads im Body, Query-Parameter, usw.
* Response-Payloads.

Außerdem erhalten Sie für alles **Inline-Fehlerberichte**.

    static final int SHORT_SIZE = 2;

    private BlockPayload payload;

    protected Block(BlockPayload payload) {
        this.payload = payload;
        payload.setBlock(this);
    }

    public BlockPayload getPayload() {
        return payload;
    }

    protected void detach() {
        payload.setBlock(null);
        payload = null;
    }

    public abstract BlockPointer getPos();

        result[0].channel == channelId1
        result[0].payload == "payload 1"
        result[1] instanceof ChannelMessage
        result[1].channel == channelId2
        result[1].payload == "payload 2"
        result[2] instanceof ChannelMessage
        result[2].channel == channelId1
        result[2].payload == "payload 3"
    }

    def "can serialise EndOfStream"() {
        when:

    private final ChannelIdentifier channel;
    private final Object payload;

    public RejectedMessage(ChannelIdentifier channel, Object payload) {
        this.channel = channel;
        this.payload = payload;
    }

    @Override
    public String toString() {
        return String.format("[%s channel:%s, payload:%s]", getClass().getSimpleName(), channel, payload);
    }

    @Override
    public Delivery getDelivery() {

        private static final int TAIL_SIZE = INT_SIZE;

        private BlockPointer pos;
        private int payloadSize;

        private BlockImpl(BlockPayload payload, BlockPointer pos) {
            this(payload);
            setPos(pos);
        }

        public BlockImpl(BlockPayload payload) {
            super(payload);
            pos = null;

    val payload = Buffer()
    while (payload.completeSegmentByteCount() <= PAYLOAD_BYTE_MAX) {
      payload.writeByte('0'.code)
    }
    serverWriter.writeMessageFrame(OPCODE_BINARY, payload.snapshot())

    // Write directly to the unbuffered sink. This ensures it will become single frame.
    assertData("827e") // 'e' == 4-byte follow-up length.
    assertData(format("%04X", payload.completeSegmentByteCount()))

// get a pointer to the constructed byte slice.
type WriteSeeker struct {
	payload []byte
	off     int64
}

func (sws *WriteSeeker) Write(p []byte) (n int, err error) {
	amt := len(p)
	towrite := sws.payload[sws.off:]
	if len(towrite) < amt {
		sws.payload = append(sws.payload, make([]byte, amt-len(towrite))...)
		towrite = sws.payload[sws.off:]
	}
	copy(towrite, p)
	sws.off += int64(amt)
	return amt, nil
}