// Prepare test data
        byte[] buffer = new byte[22];
        int idFileSystem = 0x12345678;
        int sectPerAlloc = 8;
        long alloc = 1000000L;
        long free = 500000L;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset); // idFileSystem (skipped)
        offset += 4;
        SMBUtil.writeInt4(sectPerAlloc, buffer, offset);

package cmd

import (
	"syscall"
)

// Returns true if no error and there is no object or prefix inside this directory
func isDirEmpty(dirname string, legacy bool) bool {
	if legacy {
		// On filesystems such as btrfs, nfs this is not true, so fallback
		// to performing readdir() instead.
		entries, err := readDirN(dirname, 1)
		if err != nil {
			return false
		}
		return len(entries) == 0
	}

		if err != nil {
			return err
		}
		boff += consumed
		if len(name) == 0 || bytes.Equal(name, []byte{'.'}) || bytes.Equal(name, []byte{'.', '.'}) {
			continue
		}

		// Fallback for filesystems (like old XFS) that don't
		// support Dirent.Type and have DT_UNKNOWN (0) there
		// instead.
		if typ == unexpectedFileMode || typ&os.ModeSymlink == os.ModeSymlink {
			fi, err := Stat(pathJoin(dirPath, string(name)))

        // Prepare buffer with SmbInfoAllocation data
        byte[] buffer = new byte[100];
        int offset = 0;

        // idFileSystem (4 bytes) - skipped in decode
        SMBUtil.writeInt4(0, buffer, offset);
        offset += 4;

        // sectPerAlloc (4 bytes)
        SMBUtil.writeInt4(8, buffer, offset);
        offset += 4;

		return errFileNotFound
	}
	if isSysErrIO(err) {
		return errFaultyDisk
	}
	if isSysErrInvalidArg(err) {
		storageLogIf(context.Background(), err)
		// For some odd calls with O_DIRECT reads
		// filesystems can return EINVAL, handle
		// these as FileNotFound instead.
		return errFileNotFound
	}
	if isSysErrNoSpace(err) {
		return errDiskFull
	}
	return err

     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        bufferIndex += 4; // skip idFileSystem

        this.sectPerAlloc = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.alloc = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    int readSmbInfoAllocationWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        final SmbInfoAllocation info = new SmbInfoAllocation();

        bufferIndex += 4; // skip idFileSystem

        info.sectPerAlloc = readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        info.alloc = readInt4(buffer, bufferIndex);
        bufferIndex += 4;

- The `KubeletSeparateDiskGC` feature gate is now beta. This split image filesystem feature enables kubelet to perform garbage collection of images (read-only layers) and/or containers (writeable layers) deployed on separate filesystems. gate is now beta. ([#126205](https://github.com/kubernetes/kubernetes/pull/126205), [@kwilczynski](https://github.com/kwilczynski))

                new Trans2QueryFSInformationResponse(Trans2QueryFSInformationResponse.SMB_INFO_ALLOCATION);
        byte[] buffer = new byte[20];
        // Mock data for SmbInfoAllocation
        // idFileSystem (4 bytes, skipped)
        writeInt4(100, buffer, 4); // sectPerAlloc
        writeInt4(1000, buffer, 8); // alloc
        writeInt4(500, buffer, 12); // free
        writeInt2(512, buffer, 16); // bytesPerSect

        assertTrue(exception.getMessage().contains("FILE_NOT_FOUND"));
        assertTrue(exception.getMessage().contains("test.txt"));
        assertEquals(SmbOperationException.ErrorCategory.FILE_SYSTEM, exception.getErrorCategory());
        assertFalse(exception.isRetryable());
    }

    @Test
    @DisplayName("Should create exception with cause")
    void testCreationWithCause() {
        // Given