return MoreObjects.firstNonNull(valueStrength, Strength.STRONG);
  }

  /**
   * Builds a thread-safe map. This method does not alter the state of this {@code MapMaker}
   * instance, so it can be invoked again to create multiple independent maps.
   *
   * <p>The bulk operations {@code putAll}, {@code equals}, and {@code clear} are not guaranteed to

   *
   * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not
   * across calls to multiple listeners. Specifically, a given listener will have its callbacks
   * invoked in the same order as the underlying service enters those states. Additionally, at most
   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks

    }

    /**
     * SSO logout endpoint.
     *
     * This method handles SSO logout requests, coordinating with the SSO provider
     * to properly terminate the user's SSO session. It may involve redirecting
     * to the SSO provider's logout endpoint or performing local logout operations.
     *
     * @return ActionResponse directing to the logout page or SSO provider logout endpoint
     */
    @Execute

For "synchronous" (contrary to "asynchronous") they commonly also use the term "sequential", because the computer / program follows all the steps in sequence before switching to a different task, even if those steps involve waiting.

### Concurrency and Burgers { #concurrency-and-burgers }

This idea of **asynchronous** code described above is also sometimes called **"concurrency"**. It is different from **"parallelism"**.

     * @throws CIFSException
     */
    private void setupMocksForAuth() throws Exception {
        // This is a simplified way to get a transport context into the servlet.
        // A more robust solution might involve reflection or modifying the servlet for testability.
        try {
            java.lang.reflect.Field transportContextField = NtlmServlet.class.getDeclaredField("transportContext");

   * {@code asList().contains(target)}.
   */
  public boolean contains(long target) {
    return indexOf(target) >= 0;
  }

  /**
   * Invokes {@code consumer} for each value contained in this array, in order.
   *
   * @since 33.4.0 (but since 22.0 in the JRE flavor)
   */
  @IgnoreJRERequirement // We rely on users not to call this without library desugaring.

   * {@code asList().contains(target)}.
   */
  public boolean contains(int target) {
    return indexOf(target) >= 0;
  }

  /**
   * Invokes {@code consumer} for each value contained in this array, in order.
   *
   * @since 22.0 (but only since 33.4.0 in the Android flavor)
   */
  public void forEach(IntConsumer consumer) {
    checkNotNull(consumer);

   * is true.
   *
   * <p>For example:
   *
   * {@snippet :
   * Equivalence<Person> SAME_AGE = Equivalence.equals().onResultOf(GET_PERSON_AGE);
   * }
   *
   * <p>{@code function} will never be invoked with a null value.
   *
   * <p>Note that {@code function} must be consistent according to {@code this} equivalence
   * relation. That is, invoking {@link Function#apply} multiple times for a given value must return

 * @since 2.0
 */
@GwtCompatible
public final class Functions {
  private Functions() {}

  /**
   * A function equivalent to the method reference {@code Object::toString}. The function simply
   * invokes {@code toString} on its argument and returns the result. It throws a {@link
   * NullPointerException} on null input.
   *
   * <p><b>Warning:</b> The returned function may not be <i>consistent with equals</i> (as

 * methods will throw {@link NullPointerException} if any given element is null.
 *
 * <p><b>Warning: joiner instances are always immutable</b>; a configuration method such as {@code
 * useForNull} has no effect on the instance it is invoked on! You must store and use the new joiner
 * instance returned by the method. This makes joiners thread-safe, and safe to store as {@code
 * static final} constants.
 *
 * {@snippet :
 * // Bad! Do not do this!