}

  private static final class NodeAndRemainingSuccessors<N> {
    final N node;

    /**
     * The successors left to be visited, or {@code null} if we just added this {@code
     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the
     * successors if we determine that we need them after we've performed the initial processing of
     * the node.
     */

  }

  private static final class NodeAndRemainingSuccessors<N> {
    final N node;

    /**
     * The successors left to be visited, or {@code null} if we just added this {@code
     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the
     * successors if we determine that we need them after we've performed the initial processing of
     * the node.
     */

    return new CompactLinkedHashSet<>(expectedSize);
  }

  private static final int ENDPOINT = -2;

  // TODO(user): predecessors and successors should be collocated (reducing cache misses).
  // Might also explore collocating all of [hash, next, predecessor, successor] fields of an
  // entry in a *single* long[], though that reduces the maximum size of the set by a factor of 2

  /**

  ElementOrder<E> edgeOrder();

  //
  // Element-level accessors
  //

  /**
   * Returns a live view of the nodes which have an incident edge in common with {@code node} in
   * this graph.
   *
   * <p>This is equal to the union of {@link #predecessors(Object)} and {@link #successors(Object)}.
   *

        if (current == State.HALF_OPEN) {
            int successes = halfOpenSuccesses.incrementAndGet();
            if (successes >= successThreshold) {
                if (state.compareAndSet(State.HALF_OPEN, State.CLOSED)) {
                    stateChangeTime.set(System.currentTimeMillis());
                    log.info("Circuit breaker {} closed after {} successful attempts", name, successes);
                }
            }
        }

        if (currentState == State.HALF_OPEN) {
            int successes = successCount.incrementAndGet();
            log.debug("[{}] Success in HALF_OPEN state ({}/{})", name, successes, successThreshold);

            if (successes >= successThreshold) {
                log.info("[{}] Circuit breaker closing after {} successful attempts", name, successes);
                transitionTo(State.CLOSED);
            }

    }
  }

  private static <T extends @Nullable Object> void successor(AvlNode<T> a, AvlNode<T> b) {
    a.succ = b;
    b.pred = a;
  }

  private static <T extends @Nullable Object> void successor(
      AvlNode<T> a, AvlNode<T> b, AvlNode<T> c) {
    successor(a, b);
    successor(b, c);
  }

  /*

        // Realm accessors
        assertNull(auth.getRealm());
        auth.setRealm("EXAMPLE.COM");
        assertEquals("EXAMPLE.COM", auth.getRealm());

        // Service accessors
        assertEquals("cifs", auth.getService());
        auth.setService("");
        assertEquals("", auth.getService());

        // Lifetime accessors (edge: zero/negative)
        auth.setUserLifeTime(0);

            assertSame(sid, captor.getValue()[0]);
        }

        @Test
        @DisplayName("Weak resolve via initContext triggers only once on accessors")
        void testResolveWeakInitContext() throws SmbException, CIFSException {
            SID sid = new SID("S-1-5-21-1-2");
            sid.initContext("srv", mockCtx);

    values[size] = value;

    insertIntoTableKToV(size, keyHash);
    insertIntoTableVToK(size, valueHash);

    int successor =
        (predecessor == ENDPOINT) ? firstInInsertionOrder : nextInInsertionOrder[predecessor];
    setSucceeds(predecessor, size);
    setSucceeds(size, successor);
    size++;
    modCount++;
    return null;
  }

  /**