byte[] buffer = new byte[28];
        Arrays.fill(buffer, 0, 24, (byte) 0xAA);

        // Decode with len = 24 (minimum valid)
        int bytesConsumed = response.decode(buffer, 0, 24);

        // Verify - should consume 28 bytes even though len is 24
        assertEquals(28, bytesConsumed, "Should consume 28 bytes");

        byte[] resumeKey = response.getResumeKey();

            }
            n = m + 1;
            kn[m] = kn[n] = 0;
            for (j = 0; j < 28; ++j) {
                l = j + totrot[i];
                if (l < 28) {
                    pcr[j] = pc1m[l];
                } else {
                    pcr[j] = pc1m[l - 28];
                }
            }
            for (j = 28; j < 56; ++j) {
                l = j + totrot[i];
                if (l < 56) {

            bufferIndex = start + ownerUOffset;
            owner_user = new SID(buffer, bufferIndex);
            bufferIndex += 28; // ???
        }

        if (ownerGOffset > 0) {
            bufferIndex = start + ownerGOffset;
            owner_group = new SID(buffer, bufferIndex);
            bufferIndex += 28; // ???
        }

        bufferIndex = start + daclOffset;

        if (daclOffset != 0) {

    assertEquals(Range.atMost(8), range.span(Range.atMost(2)));

    // adjacent below
    assertEquals(Range.closed(2, 8), range.span(Range.closedOpen(2, 4)));
    assertEquals(Range.atMost(8), range.span(Range.lessThan(4)));

    // overlap below
    assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 6)));
    assertEquals(Range.atMost(8), range.span(Range.atMost(6)));

    // enclosed with same start

        byte[] blob = new byte[28 + avPairsLength + 4];
        Encdec.enc_uint32le(0x00000101, blob, 0); // Header
        Encdec.enc_uint32le(0x00000000, blob, 4); // Reserved
        Encdec.enc_uint64le(nanos1601, blob, 8);
        System.arraycopy(clientChallenge, 0, blob, 16, 8);
        Encdec.enc_uint32le(0x00000000, blob, 24); // Unknown
        System.arraycopy(avPairs, 0, blob, 28, avPairsLength);

            assertTrue(bytesRead > 0);
            // readDataWireFormat returns bytes consumed from header, not full buffer
            assertEquals(28, bytesRead); // Header + one referral structure
            assertNotNull(response.getDfsResponse());
        }

        @Test
        @DisplayName("Should handle readDataWireFormat with offset")

        Trans2QueryFSInformationResponse response =
                new Trans2QueryFSInformationResponse(Trans2QueryFSInformationResponse.SMB_QUERY_FS_SIZE_INFO);
        byte[] buffer = new byte[28];
        // Mock data for SmbQueryFSSizeInfo
        writeInt8(2000, buffer, 0); // total allocation units
        writeInt8(1000, buffer, 8); // free allocation units

            bb.putShort((short) 20); // pathOffset
            bb.putShort((short) 24); // altPathOffset
            bb.putShort((short) 28); // nodeOffset

            // Add path string at offset 20 (8 + 20 = 28)
            bb.position(28);
            bb.put("\\test\0".getBytes(StandardCharsets.UTF_16LE));

            int bytesDecoded = buffer.decode(testBuffer, 0, testBuffer.length);

    @Test
    public void testExcessiveBufferSizes() {
        byte[] buffer = createBasicNegotiateResponseBuffer();

        // Test excessive maxTransactSize (> 16MB)
        SMBUtil.writeInt4(20 * 1024 * 1024, buffer, 28); // 20MB
        SMBUtil.writeInt4(1024 * 1024, buffer, 32); // 1MB read size - valid
        SMBUtil.writeInt4(1024 * 1024, buffer, 36); // 1MB write size - valid

    assertEquals(Range.atMost(8), range.span(Range.atMost(2)));

    // adjacent below
    assertEquals(Range.closed(2, 8), range.span(Range.closedOpen(2, 4)));
    assertEquals(Range.atMost(8), range.span(Range.lessThan(4)));

    // overlap below
    assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 6)));
    assertEquals(Range.atMost(8), range.span(Range.atMost(6)));

    // enclosed with same start