// Then
            assertNotNull(children1, "All children iterator should not be null");
            assertNotNull(children2, "Wildcard children iterator should not be null");
            assertNotNull(children3, "Name filter children iterator should not be null");
            assertNotNull(children4, "Resource filter children iterator should not be null");

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.jspecify.annotations.Nullable;

/**
 * Note this class is a copy of {@link com.google.common.collect.AbstractIterator} (for dependency
 * reasons).
 */
@GwtCompatible
abstract class AbstractIterator<T extends @Nullable Object> implements Iterator<T> {
  private State state = State.NOT_READY;

  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *

    return getEntryNullReplaces().getValue();
  }

  protected K getKeyForNullValue() {
    return getEntryNullReplaces().getKey();
  }

  private Entry<K, V> getEntryNullReplaces() {
    Iterator<Entry<K, V>> entries = getSampleElements().iterator();
    for (int i = 0; i < getNullLocation(); i++) {
      entries.next();
    }
    return entries.next();
  }

  protected void initMultimapWithNullKey() {

    this.nodeToOutEdge = checkNotNull(nodeToEdgeMap);
    this.targetNode = checkNotNull(targetNode);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    E connectingEdge = getConnectingEdge();
    return (connectingEdge == null)
        ? ImmutableSet.<E>of().iterator()
        : Iterators.singletonIterator(connectingEdge);
  }

  @Override
  public int size() {
    return getConnectingEdge() == null ? 0 : 1;
  }

   *
   * Similarly, we avoid having those methods *implemented* in terms of *other* TestSet methods
   * that will perform holdsLock assertions:
   *
   * - For iterator(), we can accomplish that by not overriding iterator() at all. That way, we
   *   inherit an implementation that forwards to the delegate collection, which performs no
   *   holdsLock assertions.
   *

        StringBuilder builder = new StringBuilder();
        builder.append("type:").append(getType());
        builder.append('{');

        Iterator<Map.Entry<String, RequirementMatcher>> providesIter =
                provides.entrySet().iterator();
        while (providesIter.hasNext()) {
            Map.Entry<String, RequirementMatcher> provideEntry = providesIter.next();

    Object one = new Object();
    cache.getUnchecked(one);
    CacheStats stats = cache.stats();
    assertEquals(1, stats.requestCount());
    assertEquals(0, stats.hitCount());
    assertThat(stats.hitRate()).isEqualTo(0.0);
    assertEquals(1, stats.missCount());
    assertThat(stats.missRate()).isEqualTo(1.0);
    assertEquals(1, stats.loadCount());
    long totalLoadTime = stats.totalLoadTime();

  CacheBuilderFactory withValueStrengths(Set<Strength> valueStrengths) {
    this.valueStrengths = new LinkedHashSet<>(valueStrengths);
    return this;
  }

  Iterable<CacheBuilder<Object, Object>> buildAllPermutations() {
    Iterable<List<Object>> combinations =
        buildCartesianProduct(
            concurrencyLevels,
            initialCapacities,
            maximumSizes,
            expireAfterWrites,

      return standardToString();
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
      return new StandardEntrySet() {
        @Override
        public Iterator<Entry<K, V>> iterator() {
          return backingMap.entrySet().iterator();
        }
      };
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean isEmpty() {