for (int i = 0; i < codes.length; i++) {
            if (codes[i] == code) {
                return Optional.of(msgs[i]);
            }
        }
        return Optional.empty();
    }

    // Producer for code->message pairs covering all known constants (happy path)
    static Stream<Arguments> knownCodeMessagePairs() {
        return Stream.of(Arguments.of(WinError.ERROR_SUCCESS, "The operation completed successfully."),

  /** The bytes consumed and acknowledged by the stream. */
  val readBytes: WindowCounter = WindowCounter(id)

  /** The total number of bytes produced by the application. */
  var writeBytesTotal = 0L
    internal set

  /** The total number of bytes permitted to be produced by incoming `WINDOW_UPDATE` frame. */
  var writeBytesMaximum: Long = connection.peerSettings.initialWindowSize.toLong()
    internal set

        final ExtractData result = textExtractor.getText(in, null);

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertTrue("Empty input should produce empty content", result.getContent().isEmpty());
    }

    /**
     * Test extraction with large text content.
     */
    public void test_getText_largeContent_extractsSuccessfully() {

   * {@code node}'s incoming edges <i>against</i> the direction (if any) of the edge.
   *
   * <p>Some algorithms that operate on a {@code PredecessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *

   * edges". For that functionality, see {@link Graphs#reachableNodes(Graph, Object)}.
   *
   * <p>Some algorithms that operate on a {@code SuccessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *

          // can't know without submitting something to the executor) so queue to run iteratively.
          // Task must be null, since each execution on this executor can only produce one more
          // execution.
          checkState(submittingTaskQueue.nextTask == null);
          submittingTaskQueue.nextTask = task;

     * Possibly appends the given domain name to the host name if it is currently unqualified
     *
     * @param domain the domain name to append
     */
    void fixupDomain(String domain);

    /**
     * Reduces path consumed by the given value
     *
     * @param i the number of characters to strip from path consumed
     */
    void stripPathConsumed(int i);

    @Override
    DfsReferralDataInternal next();

      currentThread.interrupt();
    }
    /*
     * TODO(cpovirk): Clear interrupt status here? We currently don't, which means that an interrupt
     * before, during, or after runInterruptibly() (unless it produced an InterruptedException
     * caught above) can linger and affect listeners.
     */
  }

  /**
   * Called before runInterruptibly - if true, runInterruptibly and afterRanInterruptibly will not

limitations under the License.
--------------------------------------------------------------------------------
https://github.com/elastic/elasticsearch

Elasticsearch
Copyright 2009-2015 Elasticsearch

This product includes software developed by The Apache Software
Foundation (https://www.apache.org/).
--------------------------------------------------------------------------------
https://github.com/lmenezes/elasticsearch-kopf

    return multiset;
  }

  /**
   * Returns a new {@code EnumMultiset} instance containing the given elements. Unlike {@link
   * EnumMultiset#create(Iterable)}, this method does not produce an exception on an empty iterable.
   *
   * @since 14.0
   */
  public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements, Class<E> type) {
    EnumMultiset<E> result = create(type);