});
                    when(mock.read(any(byte[].class), any(int.class), any(int.class))).thenAnswer(inv -> {
                        byte[] buffer = inv.getArgument(0);
                        int offset = inv.getArgument(1);
                        int length = inv.getArgument(2);
                        int remaining = includeContent.length - index[0];
                        if (remaining <= 0) {

        assertEquals(3, result3.getAllRecordCount());

        // Out of range offset
        PagingList<CharMappingItem> result4 = charMappingFile.selectList(10, 2);
        assertEquals(0, result4.size());
        assertEquals(3, result4.getAllRecordCount());

        // Negative offset
        PagingList<CharMappingItem> result5 = charMappingFile.selectList(-1, 2);
        assertEquals(0, result5.size());

            throwValidationError(e.getMessageCode(), this::asListHtml);
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid offset: {}", form.offset, e);
            }
            throwValidationError(messages -> messages.addErrorsResultSizeExceeded(GLOBAL), this::asListHtml);
        }

package cmd

import (
	"bytes"
	"fmt"
	"syscall"
	"unsafe"
)

func direntNamlen(dirent *syscall.Dirent) (uint64, error) {
	const fixedHdr = uint16(unsafe.Offsetof(syscall.Dirent{}.Name))
	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
	const nameBufLen = uint16(len(nameBuf))
	limit := dirent.Reclen - fixedHdr
	if limit > nameBufLen {

            // Then
            assertEquals("Hello World", result, "Should decode partial byte array correctly");
        }

        @Test
        @DisplayName("fromUNIBytes should handle offset in byte array")
        void testFromUNIBytesWithOffset() {
            // Given
            String prefix = "PREFIX";
            String target = "TARGET";
            String combined = prefix + target;

                                        </div>
                                    </div>
                                    <div class="form-group row">
                                        <div class="offset-sm-2 col-sm-10">
                                            <button type="submit" class="btn btn-primary" id="submit"
                                                    name="search"

        assertEquals(3, NtlmMessage.readUShort(dest, 0), "Length field must be 3");
        assertEquals(3, NtlmMessage.readUShort(dest, 2), "Length field must be 3 again");
        assertEquals(8, NtlmMessage.readULong(dest, 4), "Offset must point to payload start");
        byte[] actualPayload = new byte[payload.length];
        System.arraycopy(dest, 8, actualPayload, 0, payload.length);

			"23 GNU.sparse.offset=1\n25 GNU.sparse.numbytes=2\n" +
			"23 GNU.sparse.offset=3\n25 GNU.sparse.numbytes=4\n",
			map[string]string{paxGNUSparseSize: "10", paxGNUSparseNumBlocks: "2", paxGNUSparseMap: "1,2,3,4"}, true},
		{"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
			"25 GNU.sparse.numbytes=2\n23 GNU.sparse.offset=1\n",
			nil, false},

	volume := r.Form.Get(storageRESTVolume)
	filePath := r.Form.Get(storageRESTFilePath)
	offset, err := strconv.Atoi(r.Form.Get(storageRESTOffset))
	if err != nil {
		s.writeErrorResponse(w, err)
		return
	}
	length, err := strconv.Atoi(r.Form.Get(storageRESTLength))
	if err != nil {
		s.writeErrorResponse(w, err)
		return
	}
	if offset < 0 || length < 0 {
		s.writeErrorResponse(w, errInvalidArgument)
		return
	}

                                        </div>
                                    </div>
                                    <div class="form-group row">
                                        <div class="offset-sm-2 col-sm-10">
                                            <button type="submit" class="btn btn-primary" id="submit"
                                                    name="search"