import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Test cases for a {@link Table} implementation supporting reads and writes.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class AbstractTableTest<C extends @Nullable Character>
    extends AbstractTableReadTest<C> {

 */
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@ElementTypesAreNonnullByDefault
public abstract class AbstractMapTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractContainerTester<Map<K, V>, Entry<K, V>> {
  protected Map<K, V> getMap() {
    return container;
  }

  @Override
  protected Collection<Entry<K, V>> actualContents() {

    final CountDownLatch exitLatch = new CountDownLatch(1);
    final TrustedListenableFutureTask<@Nullable Void> task =
        TrustedListenableFutureTask.create(
            new Callable<@Nullable Void>() {
              @Override
              public @Nullable Void call() throws Exception {
                enterLatch.countDown();
                new CountDownLatch(1).await(); // wait forever

import java.util.SortedSet;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of {@link Multisets#unmodifiableSortedMultiset(SortedMultiset)} for GWT.
 *
 * @author Louis Wasserman
 */
@ElementTypesAreNonnullByDefault
final class UnmodifiableSortedMultiset<E extends @Nullable Object> extends UnmodifiableMultiset<E>
    implements SortedMultiset<E> {

import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Ignore;

/**
 * Tester for {@code Multimap.equals}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@ElementTypesAreNonnullByDefault
public class MultimapEqualsTester<K extends @Nullable Object, V extends @Nullable Object>

      new IteratorOperation() {
        @Override
        public @Nullable Object execute(Iterator<?> iterator) {
          iterator.remove();
          return null;
        }
      };

  private static final IteratorOperation NEXT_METHOD =
      new IteratorOperation() {
        @Override
        public @Nullable Object execute(Iterator<?> iterator) {
          return iterator.next();
        }

 *
 * @author Mike Bostock
 * @since 2.0
 */
@GwtCompatible(serializable = true, emulated = true)
@ElementTypesAreNonnullByDefault
public class LinkedListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements ListMultimap<K, V>, Serializable {
  /*
   * Order is maintained using a linked list containing all key-value pairs. In

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A TimeLimiter implementation which actually does not attempt to limit time at all. This may be
 * desirable to use in some unit tests. More importantly, attempting to debug a call which is

    } catch (UnsupportedOperationException e) {
      return;
    }

    map.put(null, unmappedValue);
    Entry<@Nullable K, V> entry = mapEntry(null, unmappedValue);
    assertTrue(entrySet.contains(entry));
    Entry<@Nullable K, @Nullable V> nonEntry = mapEntry(null, null);
    assertFalse(entrySet.contains(nonEntry));
  }

  public void testEntrySetContainsEntryNullKeyMissing() {

    }
  }

  public void testNullFriendlyTransform() {
    Iterator<@Nullable Integer> input = Arrays.<@Nullable Integer>asList(1, 2, null, 3).iterator();
    Iterator<String> result =
        Iterators.transform(
            input,
            new Function<@Nullable Integer, String>() {
              @Override
              public String apply(@Nullable Integer from) {
                return String.valueOf(from);
              }