* of their elements."
   *
   * </blockquote>
   */
  RESTRICTS_ELEMENTS,

  /**
   * Indicates that a collection has a well-defined ordering of its elements. The ordering may
   * depend on the element values, such as a {@link SortedSet}, or on the insertion ordering, such
   * as a {@link LinkedHashSet}. All list tests and sorted-collection tests automatically specify
   * this feature.
   */
  KNOWN_ORDER,

     * have the same nullness as E." Since we can't, we declare it to return nullable elements, and
     * we can override it in our non-null-guaranteeing subtypes to present a better signature to
     * their users.
     *
     * However, the checker *we* use has this special knowledge about `Collection.toArray()` anyway,

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.stream.Collector;
import org.jspecify.annotations.Nullable;

/**
 * Collectors not present in {@code java.util.stream.Collectors} that are not otherwise associated
 * with a {@code com.google.common} type.
 *
 * @author Louis Wasserman
 * @since 33.2.0 (available since 21.0 in guava-jre)
 */
@GwtCompatible

    public void test_changePassword_noChains() {
        boolean result = authenticationManager.changePassword("testuser", "newpass");
        assertTrue(result); // Returns true when no chains present
    }

    // Test changePassword with single chain success
    public void test_changePassword_singleChain_success() {
        TestAuthenticationChain chain = new TestAuthenticationChain();

        unwantedFeatures.retainAll(features);
        logger.finer(
            Platform.format(
                "%s: skipping because these features are present: %s", method, unwantedFeatures));
      }
      return false;
    }
    return true;
  }

  private static boolean intersect(Set<?> a, Set<?> b) {
    return !disjoint(a, b);
  }

    }

    @Test
    @DisplayName("seq ctor: unknown field tag causes failure")
    void sequenceConstructor_unknownField_throws() {
        // Arrange: only an unexpected tag is present
        ASN1EncodableVector v = new ASN1EncodableVector();
        v.add(new DERTaggedObject(true, 99, new ASN1Integer(1)));
        ASN1Sequence seq = new DERSequence(v);

        // Act + Assert

    private static final List<String> TRANSLATED_PATH_EXPRESSIONS;

    static {
        List<String> translatedPrefixes = new ArrayList<>();

        // MNG-1927, MNG-2124, MNG-3355:
        // If the build section is present and the project directory is non-null, we should make
        // sure interpolation of the directories below uses translated paths.

        // Query was processed successfully

        // Query was processed successfully
    }

    public void test_convertWildcardQuery_withBothWildcards() throws Exception {
        // Test with both wildcards already present
        QueryContext queryContext = new QueryContext("*test*", false);
        WildcardQuery wildcardQuery = new WildcardQuery(new Term(Constants.DEFAULT_FIELD, "*test*"));

  }

  /** Returns an {@link EndpointPair} representing the endpoints of an undirected edge. */
  public static <N> EndpointPair<N> unordered(N nodeU, N nodeV) {
    // Swap nodes on purpose to prevent callers from relying on the "ordering" of an unordered pair.
    return new Unordered<>(nodeV, nodeU);
  }

  /** Returns an {@link EndpointPair} representing the endpoints of an edge in {@code graph}. */

 * text is performed automatically by the relevant parser.
 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code
 * "Foo&lt;Bar&gt;"} to prevent {@code "<Bar>"} from being confused with an XML tag. When the
 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *