* Reads a count corresponding to a serialized map, multiset, or multimap. It returns the size of
   * a map serialized by {@link #writeMap(Map, ObjectOutputStream)}, the number of distinct elements
   * in a multiset serialized by {@link #writeMultiset(Multiset, ObjectOutputStream)}, or the number
   * of distinct keys in a multimap serialized by {@link #writeMultimap(Multimap,
   * ObjectOutputStream)}.
   */

  private volatile long autoIncrementStepNanos;

  /** Advances the ticker value by {@code time} in {@code timeUnit}. */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  @CanIgnoreReturnValue
  public FakeTicker advance(long time, TimeUnit timeUnit) {
    return advance(timeUnit.toNanos(time));
  }

  /** Advances the ticker value by {@code nanoseconds}. */

    // forward map ordered by currency
    assertThat(bimap.keySet())
        .containsExactly(Currency.DOLLAR, Currency.FRANC, Currency.PESO)
        .inOrder();
    // forward map ordered by currency (even for country values)
    assertThat(bimap.values())
        .containsExactly(Country.CANADA, Country.SWITZERLAND, Country.CHILE)
        .inOrder();
    // backward map ordered by country

  }

  /**
   * Find all the constraints explicitly or implicitly specified by a single tester annotation.
   *
   * @param testerAnnotation a tester annotation
   * @return the requirements specified by the annotation
   * @throws ConflictingRequirementsException if the requirements are mutually inconsistent.
   */

/**
 * A semi-persistent mapping from keys to values. Values are automatically loaded by the cache, and
 * are stored in the cache until either evicted or manually invalidated. The common way to build
 * instances is using {@link CacheBuilder}.
 *
 * <p>Implementations of this interface are expected to be thread-safe, and can be safely accessed
 * by multiple concurrent threads.
 *

import com.google.common.annotations.GwtCompatible;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * To be implemented by test generators that can produce test subjects without requiring any
 * parameters.
 *
 * @param <T> the type created by this generator.
 * @author George van den Driessche
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

    @SuppressWarnings("unused") // Called by reflection
    private void privateMethod() {}

    @SuppressWarnings("unused") // Called by reflection
    void packagePrivateMethod() {}

    @SuppressWarnings("unused") // Called by reflection
    protected void protectedMethod() {}

    @SuppressWarnings("unused") // Called by reflection
    public void publicMethod() {}
  }

/**
 * Create integer sets for testing collections that are sorted by natural ordering.
 *
 * @author Chris Povirk
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class TestIntegerSortedSetGenerator extends TestIntegerSetGenerator {
  @Override
  protected abstract SortedSet<Integer> create(Integer[] elements);

  /** Sorts the elements by their natural ordering. */
  @Override

 * @author Hayward Chan
 */
@ElementTypesAreNonnullByDefault
final class SingletonImmutableList<E> extends ForwardingImmutableList<E> {

  final transient List<E> delegate;
  // This reference is used both by the custom field serializer, and by the
  // GWT compiler to infer the elements of the lists that needs to be
  // serialized.
  E element;

  SingletonImmutableList(E element) {
    this.delegate = singletonList(checkNotNull(element));

          return AbstractExecutionThreadService.this.toString();
        }
      };

  /** Constructor for use by subclasses. */
  protected AbstractExecutionThreadService() {}

  /**
   * Start the service. This method is invoked on the execution thread.
   *
   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**