*/
    int FILE_NOTIFY_CHANGE_STREAM_SIZE = 0x00000400;

    /**
     * Any change to the data in a named stream of a file in the watched directory or subtree causes a change notification wait operation to return.
     */
    int FILE_NOTIFY_CHANGE_STREAM_WRITE = 0x00000800;

    // actions returned
    /**

import jcifs.internal.smb1.AndXServerMessageBlock;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Read AndX request message.
 *
 * This command is used to read data from a file that has been
 * previously opened with an Open command.
 */
public class SmbComReadAndX extends AndXServerMessageBlock {

    private long offset;
    private int fid;
    int openTimeout;

     *
     * @return the server realm
     */
    public String getServerRealm() {
        return this.serverRealm;
    }

    /**
     * Returns the encrypted data from the ticket.
     *
     * @return the KerberosEncData object
     */
    public KerberosEncData getEncData() {
        return this.encData;
    }

        }

        @Test
        @DisplayName("Should decode buffer correctly")
        void testDecode() throws SMBProtocolDecodingException {
            // Prepare test buffer with sample data
            byte[] buffer = new byte[24];
            // Skip idFileSystem (4 bytes)
            buffer[4] = 0x08; // sectPerAlloc = 8
            buffer[8] = 0x00;
            buffer[9] = 0x10; // alloc = 4096

bucket. For example, you could store `spark.csv` (version `ede336f2`) and `spark.csv` (version `fae684da`) in a single bucket. Versioning protects you from unintended overwrites, deletions, protect objects with retention policies.

To control data retention and storage usage, use object versioning with [object lifecycle management](https://github.com/minio/minio/blob/master/docs/bucket/lifecycle/README.md).  If you have an object expiration lifecycle policy in your non-versioned bucket and you...

        // Verify total length includes scope
        assertEquals(33 + name.scope.length() + 2, length);
    }

    @Test
    void readWireFormat_shouldDecodeNameCorrectly() {
        // Prepare encoded data for "TEST" with type 0x20
        byte[] src = new byte[100];
        src[0] = 0x20; // First byte

        // Encode "TEST" (0x54 0x45 0x53 0x54)
        // T=0x54: upper nibble 0x5->F(0x46), lower nibble 0x4->E(0x45)

   * designed for this nonstandard interaction will use it. As of 2019-01, the only widely-used
   * implementation of this pattern is [gRPC][grpc].
   *
   * Because the encoding of interleaved data is not well-defined for HTTP/1, duplex request
   * bodies may only be used with HTTP/2. Calls to HTTP/1 servers will fail before the HTTP request

  @GwtIncompatible // java.io.ObjectInputStream
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    @SuppressWarnings("unchecked") // reading data stored by writeObject
    Class<E> localType = (Class<E>) requireNonNull(stream.readObject());
    type = localType;
    enumConstants = type.getEnumConstants();
    counts = new int[enumConstants.length];

        FileRenameInformation2 info = new FileRenameInformation2(unicodeFileName, false);

        byte[] buffer = new byte[200];
        int bytesWritten = info.encode(buffer, 0);

        // Verify the encoded data
        int nameLength = SMBUtil.readInt4(buffer, 16);
        byte[] nameBytes = new byte[nameLength];
        System.arraycopy(buffer, 20, nameBytes, 0, nameLength);

		}
	}
	defer syscall.Close(fd)

	bufp := direntPool.Get()
	defer direntPool.Put(bufp)
	buf := *bufp

	boff := 0 // starting read position in buf
	nbuf := 0 // end valid data in buf

	for {
		if boff >= nbuf {
			boff = 0
			stop := globalOSMetrics.time(osMetricReadDirent)
			nbuf, err = syscall.ReadDirent(fd, buf)
			stop()
			if err != nil {
				if isSysErrNotDir(err) {