assertArrayEquals(secondData, secondResult);
    }

    @Test
    void testReadDataWireFormatWithOffset() throws SMBProtocolDecodingException {
        // Test reading data from different buffer offsets
        byte[] testData = "Test data with offset".getBytes();
        byte[] buffer = new byte[200];
        int offset = 50;

                                : null)
                .build();

        context.eventSpyDispatcher.onEvent(toolchainsRequest);

        context.logger.debug("Reading installation toolchains from '" + installationToolchainsFile + "'");
        context.logger.debug("Reading user toolchains from '" + userToolchainsFile + "'");

        ToolchainsBuilderResult toolchainsResult =

labels.jobStatus=Status
labels.labelTypeIds=Labels
labels.lang=Language
labels.outputs=Outputs
labels.pos=Part-of-speech
labels.purgeJobLogDay=Delete old job logs
labels.purgeUserInfoDay=Delete old user logs
labels.reading=Reading
labels.roleTypeIds=Role IDs
labels.scriptData=Script
labels.scriptResult=Result
labels.scriptType=Execution Method
labels.segmentation=Segmentation
labels.startTime=Start Time
labels.target=Target

        }

        try {
            // In real implementation, this would perform RDMA read into the buffer
            // For skeleton implementation, simulate reading the requested amount
            int bytesToRead = Math.min(length, buffer.remaining());

            // Simulate RDMA read operation

    public fun onRequestStart(socketEffect: SocketEffect?): Builder =
      apply {
        this.onRequestStart = socketEffect
      }

    /**
     * Process the response without even attempting to reading the request body. For HTTP/2 this
     * will close the response stream after the response body or trailers. For HTTP/1 this will
     * close the socket after the response body or trailers.
     */

			i, err = d.object()
		}
		return i, Object, err
	default:
		return nil, Unknown, d.mkError(ErrSyntax, "looking for beginning of value")
	}
}

// string called by `any` or `object`(for map keys) after reading `"`
func (d *Decoder) string() (string, error) {
	d.scratch.reset()
	c := d.next()

scan:
	for {
		switch {
		case c == '"':
			return string(d.scratch.bytes()), nil
		case c == '\\':

        final EditBody body = new EditBody();
        body.id = entity.getId();
        body.dictId = dictId;
        body.token = entity.getToken();
        body.reading = entity.getReading();
        body.pos = entity.getPos();
        body.segmentation = entity.getSegmentation();
        return body;
    }

            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setPermissions(toStringArray(source.get("permissions")));
            result.setReading(DfTypeUtil.toString(source.get("reading")));
            result.setSuggestWord(DfTypeUtil.toString(source.get("suggestWord")));
            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));

	resp := rw.Result()
	if resp.StatusCode != 123 {
		t.Fatalf("unexpected status: %v", resp.StatusCode)
	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Fatalf("reading response body failed: %v", err)
	}
	if string(body) != "hello" {
		t.Fatalf("response body incorrect: %v", string(body))
	}

	// Check that Unwrap works
	if trw.Unwrap() != rw {

A subroute on a client must match a subroute on the server. So routes cannot be used for dynamic routing, unlike HTTP.

Handlers should remain backwards compatible. If a breaking API change is required, a new handler ID should be created.

## Setup & Configuration

A **Manager** is used to manage all incoming and outgoing connections to a server.

On startup all remote servers must be specified.