* Generally speaking, this class reduces object allocation and memory consumption at the price of
 * moderately increased constant factors of CPU. Only use this class when there is a specific reason
 * to prioritize memory over CPU.
 *
 * @author Louis Wasserman
 * @author Jon Noack
 */
@GwtIncompatible // not worth using in GWT for now
class CompactHashMap<K extends @Nullable Object, V extends @Nullable Object>

KEPs or supporting documentation, please reference a specific commit and avoid
linking directly to the master branch. This ensures that links reference a
specific point in time, rather than a document that may change over time.

See here for guidance on getting permanent links to files: https://help.github.com/en/articles/getting-permanent-links-to-files

Please use the following format for linking documentation:
- [KEP]: <link>

        m.region(pos, input.length());
        if (m.find()) {
            pos = m.start();
        } else {
            pos = input.length();
        }
    }

    /**
     * Moves the position over the given pattern if currently looking at the pattern. Does nothing if not.
     */
    public void skip(Pattern pattern) {
        Matcher m = pattern.matcher(input);
        m.region(pos, input.length());

      return ((Set<?>) iterable).contains(element) ? 1 : 0;
    }
    return Iterators.frequency(iterable.iterator(), element);
  }

  /**
   * Returns an iterable whose iterators cycle indefinitely over the elements of {@code iterable}.
   *
   * <p>That iterator supports {@code remove()} if {@code iterable.iterator()} does. After {@code

     * @param result the negotiation result code
     * @param mechanism the selected authentication mechanism OID
     * @param mechanismToken the response token for the selected mechanism
     * @param mechanismListMIC the MIC over the mechanism list
     */
    public NegTokenTarg(final int result, final ASN1ObjectIdentifier mechanism, final byte[] mechanismToken,
            final byte[] mechanismListMIC) {
        setResult(result);

import org.mockito.ArgumentCaptor;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class DosErrorTest {

    // Helper that performs a lookup over the constants exposed by DosError.
    // Returns -1 if the DOS code is not mapped.
    private static int findNtStatusOrMinusOne(int dosCode) {
        for (int[] pair : DosError.DOS_ERROR_CODES) {

    /*
     * In principle, a Multimap implementation could add e3 first before failing on the null. But
     * that seems unlikely enough to be worth complicating the test over, especially if there's any
     * chance that a permissive test could mask a bug.
     */
    expectUnchanged();
    // Be extra thorough in case internal state was corrupted by the expected null.

    protected String version;
    protected String type;
    protected ArtifactScopeEnum artifactScope;
    protected String classifier;

    /**
     * explanation: why this MD was chosen over its siblings
     * in the resulting structure (classpath for now)
     */
    protected String why;

    /** dependencies of the artifact behind this metadata */
    protected Collection<ArtifactMetadata> dependencies;

   * java.util.NoSuchElementException NoSuchElementException}.
   *
   * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns {@code
   *     false}); depending on this <i>specific</i> exception type (over the more general {@link
   *     RuntimeException}) is discouraged
   */
  public abstract T get();

  /**
   * Returns the contained instance if it is present; {@code defaultValue} otherwise. If no default

    to enable Server Sent Events (SSE) responses.

    Works with **any HTTP method** (`GET`, `POST`, etc.), which makes it compatible
    with protocols like MCP that stream SSE over `POST`.

    The actual encoding logic lives in the FastAPI routing layer. This class
    serves mainly as a marker and sets the correct `Content-Type`.
    """

    media_type = "text/event-stream"