assertTrue(cycle.hasNext());
      assertEquals("b", cycle.next());
    }
  }

  public void testCycleOfTwoWithRemove() {
    Iterable<String> iterable = Lists.newArrayList("a", "b");
    Iterator<String> cycle = Iterators.cycle(iterable);
    assertTrue(cycle.hasNext());
    assertEquals("a", cycle.next());
    assertTrue(cycle.hasNext());
    assertEquals("b", cycle.next());
    assertTrue(cycle.hasNext());

 *       verified or created.
 *   <li>If a new edge needs to be created, the outgoing edges of the acquired locks are traversed
 *       to check for a cycle that reaches the lock to be acquired. If no cycle is detected, a new
 *       "safe" edge is created.
 *   <li>If a cycle is detected, an "unsafe" (cyclic) edge is created to represent a potential
 *       deadlock situation, and the appropriate Policy is executed.
 * </ul>
 *

      createDirectedGraph("aa", "dd", "ab", "ac", "ca", "cd", "bd");

  /** A directed graph with a single cycle: a -> b -> c -> d -> a. */
  private static final SuccessorsFunction<Character> CYCLE_GRAPH =
      createDirectedGraph("ab", "bc", "cd", "da");

  /**
   * Same as {@link #CYCLE_GRAPH}, but with an extra a->c edge.
   *
   * <pre>{@code
   * |--------------|
   * v              |
   * a -> b -> c -> d

   * elements.
   *
   * <p>To cycle over the iterable {@code n} times, use the following: {@code
   * Iterables.concat(Collections.nCopies(n, iterable))}
   *
   * <p><b>Java 8+ users:</b> The {@code Stream} equivalent of this method is {@code
   * Stream.generate(() -> iterable).flatMap(Streams::stream)}.
   */
  public static <T extends @Nullable Object> Iterable<T> cycle(final Iterable<T> iterable) {

      }
      // First, check whether var -> arg forms a cycle
      for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
        if (var.equalsType(t)) {
          // cycle detected, remove the entire cycle from the mapping so that
          // each type variable resolves deterministically to itself.
          // Otherwise, an F -> T cycle will end up resolving both F and T

      <version>4.13.2</version>
    </dependency>
    <dependency>
      <!--
      Do not include Truth in non-test scope! Doing so creates a problematic dependency cycle.
      -->
      <groupId>com.google.truth</groupId>
      <artifactId>truth</artifactId>
      <version>${truth.version}</version>
      <scope>test</scope>
      <exclusions>
        <exclusion>

    stimuli = (Stimulus<E, ? super I>[]) new Stimulus<?, ?>[steps];
    if (!elementsToInsertIterable.iterator().hasNext()) {
      throw new IllegalArgumentException();
    }
    elementsToInsert = Helpers.cycle(elementsToInsertIterable);
    this.features = Helpers.copyToSet(features);
    this.expectedElements = Helpers.copyToList(expectedElements);
    this.knownOrder = knownOrder;
    this.startIndex = startIndex;
  }

            ImmutableSet.of("d", "c", "b", "a"));
    for (boolean byAscendingSize : new boolean[] {true, false}) {
      Iterable<ImmutableSet<String>> infiniteSets =
          Iterables.cycle(
              byAscendingSize
                  ? distinctCandidatesByAscendingSize
                  : Lists.reverse(distinctCandidatesByAscendingSize));
      for (int startIndex = 0;

            ImmutableSet.of("d", "c", "b", "a"));
    for (boolean byAscendingSize : new boolean[] {true, false}) {
      Iterable<ImmutableSet<String>> infiniteSets =
          Iterables.cycle(
              byAscendingSize
                  ? distinctCandidatesByAscendingSize
                  : Lists.reverse(distinctCandidatesByAscendingSize));
      for (int startIndex = 0;

NAMESPACE com.google.common.io
NAMESPACE com.google.common.net
NAMESPACE com.google.common.testing

# Allow our dependencies for now.
NAMESPACE junit.framework
NAMESPACE org.junit

# ***** REAL CYCLES *****
# Cycle exists until future completes
FIELD com.google.common.util.concurrent.AbstractFuture.Listener.executor com.google.common.util.concurrent.ExecutionSequencer.TaskNonReentrantExecutor

# ***** FALSE POSITIVES *****