bufferIndex += 8;
        this.numberOfLinks = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.deletePending = (buffer[bufferIndex] & 0xFF) > 0;
        bufferIndex++;
        this.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override

        assertEquals(1 + expectedString.length + 1, used, "Expected exactly one command byte plus OEM string and NUL terminator");
        assertEquals(0x04, buffer[0] & 0xFF, "First byte must be SMB_COM_QUERY_INFORMATION type 0x04");
        // Verify that the string part ends with the null terminator
        assertArrayEquals(expectedString, subArray(buffer, 1, expectedString.length));

  static int load32(byte[] source, int offset) {
    // TODO(user): Measure the benefit of delegating this to LittleEndianBytes also.
    return (source[offset] & 0xFF)
        | ((source[offset + 1] & 0xFF) << 8)
        | ((source[offset + 2] & 0xFF) << 16)
        | ((source[offset + 3] & 0xFF) << 24);
  }

  /**
   * Indicates that the load and store operations will be very efficient because of use of VarHandle

        }

        off -= 4;

        b[off + 0] = (byte) SessionServicePacket.SESSION_MESSAGE;
        b[off + 1] = (byte) 0x00;
        b[off + 2] = (byte) (len >> 8 & 0xFF);
        b[off + 3] = (byte) (len & 0xFF);

        out.write(b, off, 4 + len);
    }

    int readRDataWireFormat(final byte[] src, int srcIndex) {
        final int start = srcIndex;
        numberOfNames = src[srcIndex] & 0xFF;
        final int namesLength = numberOfNames * 18;
        final int statsLength = rDataLength - namesLength - 1;
        numberOfNames = src[srcIndex] & 0xFF;
        srcIndex++;
        // gotta read the mac first so we can populate addressArray with it

        assertEquals("00010203", Hexdump.toHexString(data1, 0, 8)); // 8 chars = 4 bytes

        // Test with negative byte values
        byte[] data2 = { (byte) 0xFF, (byte) 0xFE, (byte) 0x80, 0x7F };
        assertEquals("FF", Hexdump.toHexString(data2, 0, 2)); // 2 chars = 1 byte
        assertEquals("FFF", Hexdump.toHexString(data2, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)

            rpcUuid.time_hi_and_version = (short) 0xFFFF;
            rpcUuid.clock_seq_hi_and_reserved = (byte) 0xFF;
            rpcUuid.clock_seq_low = (byte) 0xFF;
            rpcUuid.node = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };

            UUID uuid = new UUID(rpcUuid);

            // Act
            String result = uuid.toString();

  fun sourceSeesBom() {
    val body = "efbbbf68656c6c6f".decodeHex().toResponseBody()
    val source = body.source()
    assertThat(source.readByte() and 0xff).isEqualTo(0xef)
    assertThat(source.readByte() and 0xff).isEqualTo(0xbb)
    assertThat(source.readByte() and 0xff).isEqualTo(0xbf)
    assertThat(source.readUtf8()).isEqualTo("hello")
  }

  @Test
  fun bytesEmpty() {
    val body = body("")

        offset += 8;
        SMBUtil.writeInt8(maxLong, buffer, offset);
        offset += 8;
        SMBUtil.writeInt4(maxInt, buffer, offset);
        offset += 4;
        buffer[offset++] = (byte) 0xFF;
        buffer[offset++] = (byte) 0xFF;

        // Decode
        int bytesDecoded = fileStandardInfo.decode(buffer, 0, buffer.length);

        // Verify
        assertEquals(22, bytesDecoded);

        bufferIndex += 8;
        info.numberOfLinks = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        info.deletePending = (buffer[bufferIndex] & 0xFF) > 0;
        bufferIndex++;
        info.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        this.info = info;

        return bufferIndex - start;
    }

    int readSmbQueryFileBasicInfoWireFormat(final byte[] buffer, int bufferIndex) {