/**
     * SMB command to check if a directory exists.
     */
    public static final byte SMB_COM_CHECK_DIRECTORY = (byte) 0x10;

    /**
     * SMB command to seek within a file.
     */
    public static final byte SMB_COM_SEEK = (byte) 0x12;

    /**
     * SMB command for file locking operations.
     */
    public static final byte SMB_COM_LOCKING_ANDX = (byte) 0x24;

    /**

            // Test with various wildcard patterns and attribute masks
            String[] wildcards = { "*.txt", "test*", null };
            int[] attributes = { 0x10, 0x20, 0x07 };

            for (int i = 0; i < wildcards.length; i++) {
                DosFileFilter dos = new DosFileFilter(wildcards[i], attributes[i]);

        // Verify structure size (25)
        assertEquals(25, SMBUtil.readInt2(buffer, bodyOffset));

        // Verify session binding flag (0x1)
        assertEquals(0x1, buffer[bodyOffset + 2]);

        // Verify security mode
        assertEquals(TEST_SECURITY_MODE, buffer[bodyOffset + 3]);

        // Verify capabilities

    static final byte SMB_COM_CHECK_DIRECTORY = (byte) 0x10;
    static final byte SMB_COM_TRANSACTION = (byte) 0x25;
    static final byte SMB_COM_TRANSACTION_SECONDARY = (byte) 0x26;
    static final byte SMB_COM_MOVE = (byte) 0x2A;
    static final byte SMB_COM_ECHO = (byte) 0x2B;
    static final byte SMB_COM_OPEN_ANDX = (byte) 0x2D;
    static final byte SMB_COM_READ_ANDX = (byte) 0x2E;

        key8[3] = (byte) (((key7[2] & 0x07) << 4 | (key7[3] & 0xff) >> 4 & 0xff) & 0xff);
        key8[4] = (byte) (((key7[3] & 0x0F) << 3 | (key7[4] & 0xff) >> 5 & 0xff) & 0xff);
        key8[5] = (byte) (((key7[4] & 0x1F) << 2 | (key7[5] & 0xff) >> 6 & 0xff) & 0xff);
        key8[6] = (byte) (((key7[5] & 0x3F) << 1 | (key7[6] & 0xff) >> 7 & 0xff) & 0xff);
        key8[7] = (byte) (key7[6] & 0x7F);
        for (i = 0; i < 8; i++) {

            byte[] buffer = new byte[24];
            // Skip idFileSystem (4 bytes)
            buffer[4] = 0x08; // sectPerAlloc = 8
            buffer[8] = 0x00;
            buffer[9] = 0x10; // alloc = 4096
            buffer[12] = 0x00;
            buffer[13] = 0x08; // free = 2048
            buffer[16] = 0x00;
            buffer[17] = 0x02; // bytesPerSect = 512

        // Write READ response body
        int dataLength = 20;
        int dataRemaining = 0;
        int dataOffsetFromHeader = 80;

        // Structure size (17 = 0x11)
        SMBUtil.writeInt2(17, buffer, bodyStart);
        // Data offset (byte - offset from header start)
        buffer[bodyStart + 2] = (byte) dataOffsetFromHeader;
        // Reserved

     */
    public static final int FILE_NO_IMTERMEDIATE_BUFFERING = 0x8;
    /**
     * All operations on the file are performed synchronously with alerts
     */
    public static final int FILE_SYNCHRONOUS_IO_ALERT = 0x10;
    /**
     * All operations on the file are performed synchronously without alerts
     */
    public static final int FILE_SYNCHRONOUS_IO_NONALERT = 0x20;
    /**

     * DCE/RPC message for NetrDfsEnumEx operation to enumerate DFS entries
     */
    public static class NetrDfsEnumEx extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x15;
        }

        /**
         * Return value from the RPC call
         */
        public int retval;
        /**
         * DFS name to enumerate
         */
        public String dfs_name;

  }

  @GwtIncompatible // Chars.fromByteArray, Chars.toByteArray
  public void testByteArrayRoundTripsFails() {
    assertThrows(IllegalArgumentException.class, () -> Chars.fromByteArray(new byte[] {0x11}));
  }

  public void testEnsureCapacity() {
    assertThat(Chars.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);
    assertThat(Chars.ensureCapacity(ARRAY1, 0, 1)).isSameInstanceAs(ARRAY1);