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);

     * AbstractFuture.executeListener to do so, since that method would have the ability to continue
     * to execute other listeners.
     *
     * What about RuntimeException? If there is a bug in set()/setValue() that produces one, it will
     * propagate, too, but only as far as AbstractFuture.executeListener, which will catch and log
     * it.
     */
    setResult(transformResult);
  }

      return split == null ? null : new GeneralSpliteratorOfPrimitive<>(split, consumerizer);
    }
  }

  /**
   * Different ways of decomposing a Spliterator, all of which must produce the same elements (up to
   * ordering, if Spliterator.ORDERED is not present).
   */
  @IgnoreJRERequirement // *should* be redundant with the annotation on SpliteratorTester
  enum SpliteratorDecompositionStrategy {

      return split == null ? null : new GeneralSpliteratorOfPrimitive<>(split, consumerizer);
    }
  }

  /**
   * Different ways of decomposing a Spliterator, all of which must produce the same elements (up to
   * ordering, if Spliterator.ORDERED is not present).
   */
  enum SpliteratorDecompositionStrategy {
    NO_SPLIT_FOR_EACH_REMAINING {
      @Override

   * should use this method over {@link #setCountCheckReturnValue(Object, int)} when they expect
   * {@code setCount()} to throw an exception, as checking the return value could produce an
   * incorrect error message like "setCount() should return the original count" instead of the
   * message passed to a later invocation of {@code fail()}, like "setCount should throw
   * UnsupportedOperationException."
   */

                MapFeature.GENERAL_PURPOSE)
            /*
             * StandardDescendingMap uses lowerEntry(), and TreeMap.lowerEntry() deliberately
             * produces immutable entries.
             *
             * TODO(cpovirk): Consider making StandardDescendingMap return a ForwardingEntry that
             * supports setValue().
             */
            .suppressing(

/**
 * Unit test for Fingerprint2011.
 *
 * @author ******@****.*** (Kyle Maddison)
 */
@NullUnmarked
public class Fingerprint2011Test extends TestCase {

  // Length of the sample string to produce
  private static final int MAX_BYTES = 1000;

  // Map from sample string lengths to the fingerprint
  private static final ImmutableSortedMap<Integer, Long> LENGTH_FINGERPRINTS =

   * we wanted to support legacy classes that implement the raw type {@code Comparable} (instead of
   * implementing {@code Comparable<Foo>}) without producing warnings. If so, we would prefer today
   * to produce warnings in that case, and we may change this method to do so in the future. Support
   * for raw {@code Comparable} types in Guava in general is tracked as <a
   * href="https://github.com/google/guava/issues/989">#989</a>.)
   *

    thread.start();
    return thread;
  }

  /**
   * Generates a test case verifying that calling any enterXxx, tryEnterXxx, or waitForXxx method
   * with a guard that doesn't match the monitor produces an IllegalMonitorStateException.
   */
  private static TestCase generateGuardWithWrongMonitorTestCase(
      Method method, boolean fair1, boolean fair2) {

  }

  private interface IteratorOperation {
    @Nullable Object execute(Iterator<?> iterator);
  }

  /**
   * Apply this method to both iterators and return normally only if both produce the same response.
   *
   * @see Stimulus#executeAndCompare(ListIterator, Iterator)
   */
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception