int generateInt() {
    return freshness.get();
  }

  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
  @Generates
  Integer generateInteger() {
    return new Integer(generateInt());
  }

  @Generates
  long generateLong() {
    return generateInt();
  }

  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
  @Generates
  Long generateLongObject() {

      boolean removal = (maximumSize == UNSET_INT) ? false : (size() > maximumSize);
      if ((removalListener != null) && removal) {
        removalListener.onRemoval(
            RemovalNotification.create(
                ignored.getKey(), ignored.getValue().getValue(), RemovalCause.SIZE));
      }
      statsCounter.recordEviction();
      return removal;
    }
  }

  /**

  /**
   * Returns the JavaLangAccess class that is present in all Sun JDKs. It is not allowed in
   * AppEngine, and not present in non-Sun JDKs.
   */
  @SuppressWarnings("removal") // b/318391980
  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  @CheckForNull
  private static Object getJLA() {
    try {
      /*

  /**
   * Returns the JavaLangAccess class that is present in all Sun JDKs. It is not allowed in
   * AppEngine, and not present in non-Sun JDKs.
   */
  @SuppressWarnings("removal") // b/318391980
  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  @CheckForNull
  private static Object getJLA() {
    try {
      /*

   * so that we get partial compile-time checking.)
   *
   * <p>This workaround should be removed at a distant future time when we no longer support Java
   * versions earlier than 8.
   */
  @SuppressWarnings("removal") // b/318391980
  private static final class TypeVariableInvocationHandler implements InvocationHandler {
    private static final ImmutableMap<String, Method> typeVariableMethods;

    static {

        : Iterators.retainAll(removeFrom.iterator(), elementsToRetain);
  }

  /**
   * Removes, from an iterable, every element that satisfies the provided predicate.
   *
   * <p>Removals may or may not happen immediately as each element is tested against the predicate.
   * The behavior of this method is not specified if {@code predicate} is dependent on {@code
   * removeFrom}.
   *

  GENERAL_PURPOSE(
      CollectionFeature.GENERAL_PURPOSE,
      SUPPORTS_SET,
      SUPPORTS_ADD_WITH_INDEX,
      SUPPORTS_REMOVE_WITH_INDEX),

  /** Features supported by lists where only removal is allowed. */
  REMOVE_OPERATIONS(CollectionFeature.REMOVE_OPERATIONS, SUPPORTS_REMOVE_WITH_INDEX);

  private final Set<Feature<? super List>> implied;

  ListFeature(Feature<? super List>... implied) {

import java.util.List;
import java.util.Random;
import java.util.RandomAccess;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests for repeated node and edge addition and removal in a {@link Network}. */
@RunWith(JUnit4.class)

public final class NetworkMutationTest {
  private static final int NUM_TRIALS = 5;
  private static final int NUM_NODES = 20;
  private static final int NUM_EDGES = 100;

   *
   * @see java.util.Collection the definition of general-purpose collections.
   */
  GENERAL_PURPOSE(SUPPORTS_ADD, SUPPORTS_REMOVE, SUPPORTS_ITERATOR_REMOVE),

  /** Features supported by collections where only removal is allowed. */
  REMOVE_OPERATIONS(SUPPORTS_REMOVE, SUPPORTS_ITERATOR_REMOVE),

  SERIALIZABLE,
  SERIALIZABLE_INCLUDING_VIEWS(SERIALIZABLE),

  SUBSET_VIEW,
  DESCENDING_VIEW,

  /**

      this.fromList = checkNotNull(fromList);
      this.function = checkNotNull(function);
    }

    /**
     * The default implementation inherited is based on iteration and removal of each element which
     * can be overkill. That's why we forward this call directly to the backing list.
     */
    @Override
    protected void removeRange(int fromIndex, int toIndex) {