}

    @Override
    public Set<N> adjacentNodes(N node) {
      return network.adjacentNodes(node);
    }

    @Override
    public Set<N> predecessors(N node) {
      return network.predecessors(node);
    }

    @Override
    public Set<N> successors(N node) {
      return network.successors(node);
    }

    @Override
    public Set<E> incidentEdges(N node) {

   *
   * @see #assertMoreInvariants
   * @param map the map to check.
   */
  protected final void assertInvariants(Map<K, V> map) {
    Set<K> keySet = map.keySet();
    Collection<V> valueCollection = map.values();
    Set<Entry<K, V>> entrySet = map.entrySet();

    assertEquals(map.size() == 0, map.isEmpty());
    assertEquals(map.size(), keySet.size());

        this.value3 = value3;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * Sets the first value.
     *
     * @param value1
     *            The first value
     */
    public void setValue1(final T1 value1) {
        this.value1 = value1;
    }

    /**

    return inverse;
  }

  @LazyInit private transient @Nullable Set<K> keySet;

  @Override
  public Set<K> keySet() {
    Set<K> result = keySet;
    return (result == null) ? keySet = new KeySet() : result;
  }

  @WeakOuter
  private final class KeySet extends ForwardingSet<K> {
    @Override
    protected Set<K> delegate() {
      return delegate.keySet();
    }

    @Override

    putEdge(N1, N2);
    putEdge(N2, N1);
    Set<Integer> n1AdjacentNodes = graph.adjacentNodes(N1);
    Set<Integer> n2AdjacentNodes = graph.adjacentNodes(N2);
    Set<Integer> n1Predecessors = graph.predecessors(N1);
    Set<Integer> n2Predecessors = graph.predecessors(N2);
    Set<Integer> n1Successors = graph.successors(N1);
    Set<Integer> n2Successors = graph.successors(N2);

            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Moves the result set to the next position.
     *
     * @param resultSet
     *            The result set. Must not be {@literal null}.
     * @return Whether the result set successfully moved to the next position.
     */
    public static boolean next(final ResultSet resultSet) {

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A set multimap which forwards all its method calls to another set multimap. Subclasses should
 * override one or more methods to modify the behavior of the backing multimap as desired per the <a

public class AbstractSetTester<E> extends AbstractCollectionTester<E> {
  /*
   * Previously we had a field named set that was initialized to the value of
   * collection in setUp(), but that caused problems when a tester changed the
   * value of set or collection but not both.
   */
  protected final Set<E> getSet() {
    return (Set<E>) collection;
  }

        assertNotNull(dataMap.get("id"), "ID should be set");
        assertNotNull(dataMap.get("doc_id"), "Doc ID should be set");
        assertNotNull(dataMap.get("click_count"), "Click count should be set");
        assertNotNull(dataMap.get("favorite_count"), "Favorite count should be set");
        assertEquals(1, indexUpdateCallback.docList.size());
    }

    @Test

      NavigableSet<E> set = (NavigableSet<E>) sortedSet;
      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
        return set.headSet(lastInclusive, true);
      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
        return set.tailSet(firstExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return set.subSet(firstExclusive, false, lastExclusive, false);