public void testTransformEntrySetContains() {
    Map<@Nullable String, @Nullable Boolean> underlying = new HashMap<>();
    underlying.put("a", null);
    underlying.put("b", true);
    underlying.put(null, true);

    Map<@Nullable String, @Nullable Boolean> map =
        transformValues(
            underlying,
            new Function<@Nullable Boolean, @Nullable Boolean>() {
              @Override

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A generator for {@code ListMultimap} implementations based on test data.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestListMultimapGenerator<K extends @Nullable Object, V extends @Nullable Object>

   *
   * @since 33.2.0 (available since 22.0 in guava-jre)
   */
  @IgnoreJRERequirement // Users will use this only if they're already using streams.
  public static <T extends @Nullable Object, E extends @Nullable Object, M extends Multiset<E>>
      Collector<T, ?, M> toMultiset(
          Function<? super T, E> elementFunction,
          ToIntFunction<? super T> countFunction,
          Supplier<M> multisetSupplier) {

   *
   * <p>To collect to an {@link ImmutableMultiset}, use {@link
   * ImmutableMultiset#toImmutableMultiset}.
   *
   * @since 22.0
   */
  public static <T extends @Nullable Object, E extends @Nullable Object, M extends Multiset<E>>
      Collector<T, ?, M> toMultiset(
          Function<? super T, E> elementFunction,
          ToIntFunction<? super T> countFunction,
          Supplier<M> multisetSupplier) {

    int nextSegmentIndex;
    int nextTableIndex;
    @Nullable Segment<K, V> currentSegment;
    @Nullable AtomicReferenceArray<ReferenceEntry<K, V>> currentTable;
    @Nullable ReferenceEntry<K, V> nextEntry;
    @Nullable WriteThroughEntry nextExternal;
    @Nullable WriteThroughEntry lastReturned;

    HashIterator() {
      nextSegmentIndex = segments.length - 1;

            MultimapBuilder.linkedHashKeys().linkedHashSetValues()::<K, V>build),
        ImmutableSetMultimap::copyOf);
  }

  static <
          T extends @Nullable Object,
          K extends @Nullable Object,
          V extends @Nullable Object,
          M extends Multimap<K, V>>
      Collector<T, ?, M> toMultimap(
          Function<? super T, ? extends K> keyFunction,

        this.classWorldManaged = classWorldManaged;
    }

    /**
     * The main entry point.
     */
    public int run(
            String[] args,
            @Nullable InputStream stdIn,
            @Nullable OutputStream stdOut,
            @Nullable OutputStream stdErr,
            boolean embedded)
            throws IOException {
        try (Invoker invoker = createInvoker()) {
            return invoker.invoke(createParser()

 * methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingMapEntry<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingObject implements Map.Entry<K, V> {
  // TODO(lowasser): identify places where thread safety is actually lost

  /** Constructor for use by subclasses. */

  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);
  private static final Iterable<@Nullable Integer> iterableNullNull =
      Arrays.asList((Integer) null, null);
  private static final Iterable<@Nullable Integer> iterableNull1 = Arrays.asList(null, 1);
  private static final Iterable<@Nullable Integer> iterable1Null = Arrays.asList(1, null);

    return forwardMultiset();
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forwardMultiset().lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forwardMultiset().firstEntry();
  }

  abstract Iterator<Entry<E>> entryIterator();

  @LazyInit private transient @Nullable Set<Entry<E>> entrySet;

  @Override