# TODO(user): Resolve cycles

NAMESPACE com.google.common.collect.testing
NAMESPACE com.google.common.collect.testing.google
NAMESPACE com.google.common.escape
NAMESPACE com.google.common.escape.testing
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 *****

 *       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>
 *

        // Session starts with usage count > 0, so acquire/release cycles maintain usage
        assertTrue(session.isInUse(), "Session should be in use initially");

        // Test acquire/release cycles (session remains in use due to initial transport acquire)
        for (int i = 0; i < 3; i++) {
            session.acquire();

    return (NavigableSet<E>) super.elementSet();
  }

  @LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;

  // TODO(b/418181860): This method creates retain cycles in J2ObjC. In order to break the cycle,
  // there needs to be separate classes for primary and descending multiset, where the primary one
  // would hold {@code @LazyInit @RetainedWith @Nullable} reference to its descending multiset, and

  }

  /**
   * Returns a fluent iterable whose {@code Iterator} cycles indefinitely over the elements of this
   * fluent iterable.
   *
   * <p>That iterator supports {@code remove()} if {@code iterable.iterator()} does. After {@code
   * remove()} is called, subsequent cycles omit the removed element, which is no longer in this

  }

  /**
   * Returns a fluent iterable whose {@code Iterator} cycles indefinitely over the elements of this
   * fluent iterable.
   *
   * <p>That iterator supports {@code remove()} if {@code iterable.iterator()} does. After {@code
   * remove()} is called, subsequent cycles omit the removed element, which is no longer in this

      count++;
    }
    return count;
  }

  /**
   * Returns an iterator that cycles indefinitely over the elements of {@code iterable}.
   *
   * <p>The returned iterator supports {@code remove()} if the provided iterator does. After {@code
   * remove()} is called, subsequent cycles omit the removed element, which is no longer in {@code

            if (headerNameIndex in 2..7) {
              // Only search a subset of the static header table. Most entries have an empty value, so
              // it's unnecessary to waste cycles looking at them. This check is built on the
              // observation that the header entries we care about are in adjacent pairs, and we
              // always know the first index of the pair.

        assertEquals(expectedSeconds, actualSeconds);
    }

    @Test
    @DisplayName("Test multiple update and digest cycles")
    void testMultipleUpdateDigestCycles() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);

        // First cycle
        byte[] data1 = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data1, 0, data1.length);

      @Override
      public Iterator<T> iterator() {
        return Iterators.cycle(iterable);
      }

      @Override
      public String toString() {
        return iterable.toString() + " (cycled)";
      }
    };
  }

  /**
   * Returns an iterable whose iterators cycle indefinitely over the provided elements.
   *