*
   * <p>This abstraction allows us to use single-instruction load and put when available, or fall
   * back on the slower approach of using Longs.fromBytes(byte...).
   */
  private interface LittleEndianBytes {
    long getLongLittleEndian(byte[] array, int offset);

    void putLongLittleEndian(byte[] array, int offset, long value);

        // Verify content
        assertArrayEquals(new byte[] { (byte) 0xFF, 0x01, 0x02, 0x03, 0x00 }, dest, "Encoded bytes should be placed at the correct offset");
    }

    @Test
    void testEncodeZeroLength() {
        // Test encoding with zero length
        byte[] data = { 0x01, 0x02, 0x03 };
        ByteEncodable encodable = new ByteEncodable(data, 0, 0);
        byte[] dest = new byte[3];

 */
public class Smb2QueryInfoRequest extends ServerMessageBlock2Request<Smb2QueryInfoResponse> implements RequestWithFileId {

    private byte infoType;
    private byte fileInfoClass;
    private final int outputBufferLength;
    private int additionalInformation;
    private int queryFlags;
    private byte[] fileId;
    private Encodable inputBuffer;

    /**
     * Constructs a SMB2 query info request with the specified configuration

    @DisplayName("Test writeUTime with zero time")
    void testWriteUTimeWithZeroTime() {
        byte[] dst = new byte[4];

        SMB1SigningDigest.writeUTime(mockConfig, 0L, dst, 0);

        assertEquals((byte) 0xFF, dst[0]);
        assertEquals((byte) 0xFF, dst[1]);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);
    }

    @Test
    @DisplayName("Test writeUTime with max time")

            SmbTreeHandleImpl sh = newTreeHandle(false); // force non-SMB2 path to avoid server-side branch
            SmbTreeHandleImpl dh = newTreeHandle(false);

            byte[][] buffers = new byte[][] { new byte[8], new byte[8] };

            when(src.toString()).thenReturn("smb://src");
            when(dest.toString()).thenReturn("smb://dest");

            // Act + Assert
            SmbException ex =

      return false;
    }

    byte[] bytes = ip.getAddress();

    if ((bytes[8] | (byte) 0x03) != (byte) 0x03) {

      // Verify that high byte of the 64 bit identifier is zero, modulo
      // the U/L and G bits, with which we are not concerned.
      return false;
    }

    return (bytes[9] == (byte) 0x00) && (bytes[10] == (byte) 0x5e) && (bytes[11] == (byte) 0xfe);
  }

  /**

        if (byte2 > (byte) 0xBF
            // Check that 1 <= plane <= 16. Tricky optimized form of:
            // if (byte1 > (byte) 0xF4
            //     || byte1 == (byte) 0xF0 && byte2 < (byte) 0x90
            //     || byte1 == (byte) 0xF4 && byte2 > (byte) 0x8F)
            || (((byte1 << 28) + (byte2 - (byte) 0x90)) >> 30) != 0
            // Third byte trailing-byte test
            || bytes[index++] > (byte) 0xBF

    void testReadLengthMaximum() {
        byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

        assertEquals(0x01FFFF, length);
    }

    @Test
    @DisplayName("readLength should handle zero length")
    void testReadLengthZero() {
        byte[] src = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

        byte[] maxGuid = new byte[16];
        Arrays.fill(maxGuid, (byte) 0xFF);

        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, maxGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        byte[] buffer = new byte[request.size()];
        request.encode(buffer, 0);

        // Verify max GUID
        byte[] extractedGuid = new byte[16];

    private static class TestServerMessageBlock extends ServerMessageBlock {
        private byte[] paramWords;
        private byte[] bytes;

        TestServerMessageBlock() {
            super();
            this.paramWords = new byte[0];
            this.bytes = new byte[0];
        }

        void setParamWords(byte[] paramWords) {
            this.paramWords = paramWords;