}
	return ok, err
}

// RLock calls read lock REST API.
func (c *lockRESTClient) RLock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRLock, &args)
}

// Lock calls lock REST API.
func (c *lockRESTClient) Lock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCLock, &args)
}

// RUnlock calls read unlock REST API.

	defer xioutil.ODirectPoolSmall.Put(bufp)

	for left > 0 {
		// Read expected hash...
		h.Reset()
		n, err := io.ReadFull(r, hashBuf)
		if err != nil {
			// Read's failed for object with right size, file is corrupt.
			return err
		}
		// Subtract hash length..
		left -= int64(n)
		if left < shardSize {
			shardSize = left
		}

		read, err := io.CopyBuffer(h, io.LimitReader(r, shardSize), *bufp)

    /**
     * Permission to read file attributes
     */
    int FILE_READ_ATTRIBUTES = 0x00000080; // 8
    /**
     * Permission to write file attributes
     */
    int FILE_WRITE_ATTRIBUTES = 0x00000100; // 9
    /**
     * Standard delete permission
     */
    int DELETE = 0x00010000; // 16
    /**
     * Permission to read the security descriptor
     */

    /**
     * Test for the readSetupWireFormat method.
     * It should always return 0.
     */
    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];
        // The method should not read anything and return 0
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 10), "readSetupWireFormat should return 0.");
    }

    /**
     * Test for the readParametersWireFormat method.

	return &pooledFlateReader{fr: fr}
}

type pooledFlateReader struct {
	mu sync.Mutex // guards Close and Read
	fr io.ReadCloser
}

func (r *pooledFlateReader) Read(p []byte) (n int, err error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	if r.fr == nil {
		return 0, errors.New("Read after Close")
	}
	return r.fr.Read(p)
}

func (r *pooledFlateReader) Close() error {
	r.mu.Lock()
	defer r.mu.Unlock()
	var err error

            assertEquals(0, response.writeDataWireFormat(null, 0));
        }

        @Test
        @DisplayName("Should handle null buffer in read operations")
        void testReadOperationsWithNullBuffer() {
            // Read operations return 0 when given null buffer - no exceptions thrown
            assertEquals(0, response.readSetupWireFormat(null, 0, 0));

        writeInt4(500, buffer, 12); // free
        writeInt2(512, buffer, 16); // bytesPerSect

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(20, bytesRead, "Should read 20 bytes");
        assertNotNull(response.info, "Info object should not be null");
        assertTrue(response.info instanceof Trans2QueryFSInformationResponse.SmbInfoAllocation, "Info should be of type SmbInfoAllocation");

        byte[] buffer = new byte[512];
        int written = originalPacket.writeWireFormat(buffer, 0);

        // Read from buffer
        ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
        SessionRequestPacket readPacket = new SessionRequestPacket(mockConfig);

        // Skip header (already read by parent class)
        bais.skip(4);
        readPacket.type = buffer[0] & 0xFF;

site4_pid=$!

export MC_HOST_minio1=http://minr0otUS2r:pBU94AGAY85e@localhost:9001
export MC_HOST_minio3=http://minr0otUS2r:pBU94AGAY85e@localhost:9003

./mc ready minio1
./mc ready minio3

./mc mb minio1/testbucket
# copy large upload to newbucket on minio1
truncate -s 17M lrgfile
expected_checksum=$(cat ./lrgfile | md5sum)

./mc cp ./lrgfile minio1/testbucket

                try {
                    // Invalidate any cached read data
                    // This would typically clear file's internal read buffers
                    // For now, we log the action as the actual implementation
                    // depends on SmbFile's internal caching mechanism
                    log.info("Invalidated read cache for: {}", path);
                } catch (Exception e) {