} catch (e: IllegalAccessException) {
      throw AssertionError("failed to get ALPN selected protocol", e)
    }
  }

  /**
   * Handle the methods of ALPN's ClientProvider and ServerProvider without a compile-time
   * dependency on those interfaces.
   */
  private class AlpnProvider(
    /** This peer's supported protocols. */
    private val protocols: List<String>,
  ) : InvocationHandler {

        when(logonInfo.getUserFlags()).thenReturn(PacConstants.LOGON_RESOURCE_GROUPS);
        assertEquals(PacConstants.LOGON_RESOURCE_GROUPS, logonInfo.getUserFlags());

        // Test with combined flags
        int combinedFlags = PacConstants.LOGON_EXTRA_SIDS | PacConstants.LOGON_RESOURCE_GROUPS;
        when(logonInfo.getUserFlags()).thenReturn(combinedFlags);

        }
    }

    /**
     * Builds a nested key path.
     *
     * @param parentKey the parent key
     * @param currentKey the current key
     * @return the combined key path
     */
    protected String buildKey(final String parentKey, final String currentKey) {
        if (StringUtil.isBlank(parentKey)) {
            return currentKey;
        }

 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file

            "maven.build.allowExpressionInEffectiveProjectVersion";

    private static final Pattern CI_FRIENDLY_EXPRESSION = Pattern.compile("\\$\\{(.+?)}");
    private static final Pattern EXPRESSION_PROJECT_NAME_PATTERN = Pattern.compile("\\$\\{(project.+?)}");

    private static final String ILLEGAL_FS_CHARS = "\\/:\"<>|?*";

    private static final String ILLEGAL_VERSION_CHARS = ILLEGAL_FS_CHARS;

    int pipeType;

    /**
     * Open the Named Pipe resource specified by the url
     * parameter. The pipeType parameter should be at least one of
     * the <code>PIPE_TYPE</code> flags combined with the bitwise OR
     * operator <code>|</code>. See the examples listed above.
     */

    /**
     * Constructs an SmbNamedPipe for a specified pipe on an SMB server.
     *

    }
    throw new IllegalArgumentException(
        lenientFormat("min (%s) must be less than or equal to max (%s)", min, max));
  }

  /**
   * Returns the values from each provided array combined into a single array. For example, {@code
   * concat(new double[] {a, b}, new double[] {}, new double[] {c}} returns the array {@code {a, b,
   * c}}.
   *
   * @param arrays zero or more {@code double} arrays

**FastAPI** sabe qué hacer en cada caso y cómo reutilizar el mismo objeto, de modo que todas las tareas en segundo plano se combinan y ejecutan en segundo plano después:

{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}

En este ejemplo, los mensajes se escribirán en el archivo `log.txt` *después* de que se envíe el response.

                }
            }
            throw new GradleException(sb.toString());
        }
    }

    private static final java.util.regex.Pattern SOURCE_LANG_PATTERN =
        java.util.regex.Pattern.compile(
            "^\\[\\s*source(?:%[\\w-]+)*\\s*,\\s*([\\w.+-]+)\\s*(?:,.*)?\\]$",
            java.util.regex.Pattern.CASE_INSENSITIVE
        );

    from jCIFS or another application will fail with the "file is being
    accessed by another process" error. The <code>FILE_SHARE_READ</code>,
    <code>FILE_SHARE_WRITE</code>, and <code>FILE_SHARE_DELETE</code> may be
    combined with the bitwise OR '|' to specify that other peocesses may read,
    write, and/or delete the file while the jCIFS user has the file open.
     *
     * @param url An smb URL representing the file to write to