*/
@GwtCompatible(serializable = true, emulated = true)
@ElementTypesAreNonnullByDefault
class ObjectCountHashMap<K extends @Nullable Object> {

  /** Creates an empty {@code ObjectCountHashMap} instance. */
  static <K extends @Nullable Object> ObjectCountHashMap<K> create() {
    return new ObjectCountHashMap<K>();
  }

  /**

@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@ElementTypesAreNonnullByDefault
public class SortedSetNavigationTester<E extends @Nullable Object> extends AbstractSetTester<E> {

  private SortedSet<E> sortedSet;
  private List<E> values;
  private @Nullable E a;
  private @Nullable E b;
  private @Nullable E c;

  @Override

import java.util.concurrent.ExecutionException;
import junit.framework.TestCase;

/**
 * Unit test for {@link FakeTimeLimiter}.
 *
 * @author Jens Nyman
 */
public class FakeTimeLimiterTest extends TestCase {

  private static final int DELAY_MS = 50;
  private static final String RETURN_VALUE = "abc";

  private TimeLimiter timeLimiter;

  @Override
  protected void setUp() throws Exception {

public class CollectionTestSuiteBuilder<E>
    extends AbstractCollectionTestSuiteBuilder<CollectionTestSuiteBuilder<E>, E> {
  public static <E> CollectionTestSuiteBuilder<E> using(TestCollectionGenerator<E> generator) {
    return new CollectionTestSuiteBuilder<E>().usingGenerator(generator);
  }

  @Override
  protected List<TestSuite> createDerivedSuites(
      FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>>

import junit.framework.TestCase;

/**
 * Tests for {@link ForwardingConcurrentMap}.
 *
 * @author Jared Levy
 */
public class ForwardingConcurrentMapTest extends TestCase {

  private static class TestMap extends ForwardingConcurrentMap<String, Integer> {
    final ConcurrentMap<String, Integer> delegate = new ConcurrentHashMap<>();

    @Override
    protected ConcurrentMap<String, Integer> delegate() {

   *
   * <p>This does not always signify that the key is now absent from the cache, as it may have
   * already been re-added.
   */
  // Technically should accept RemovalNotification<? extends K, ? extends V>, but because
  // RemovalNotification is guaranteed covariant, let's make users' lives simpler.
  void onRemoval(RemovalNotification<K, V> notification);

/**
 * GWT emulated version of {@link ImmutableList}. TODO(cpovirk): more doc
 *
 * @author Hayward Chan
 */
@ElementTypesAreNonnullByDefault
abstract class ForwardingImmutableList<E> extends ImmutableList<E> {

  ForwardingImmutableList() {}

  abstract List<E> delegateList();

  public int indexOf(@Nullable Object object) {
    return delegateList().indexOf(object);
  }

 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import java.util.Map;

@GwtCompatible
public class RegularImmutableMapMapInterfaceTest
    extends AbstractImmutableMapMapInterfaceTest<String, Integer> {
  @Override
  protected Map<String, Integer> makeEmptyMap() {
    return ImmutableMap.of();
  }

  @Override

import com.google.common.base.Predicate;
import com.google.common.collect.FilteredCollectionsTestUtil.AbstractFilteredNavigableSetTest;
import java.util.NavigableSet;

public final class SetsFilterNavigableSetTest extends AbstractFilteredNavigableSetTest {
  @Override
  NavigableSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Sets.newTreeSet(contents);
  }

  @Override
  NavigableSet<Integer> filter(

import java.util.Map;

@GwtIncompatible // GWT's ImmutableMap emulation is backed by java.util.HashMap.
public class SingletonImmutableMapWithUnhashableValueMapInterfaceTest
    extends RegularImmutableMapWithUnhashableValuesMapInterfaceTest {
  @Override
  protected Map<Integer, UnhashableObject> makePopulatedMap() {
    Unhashables unhashables = new Unhashables();