* LinkedHashMap because one target node may be mapped to both a predecessor and a successor. A
   * LinkedHashMap combines two such edges into a single node-value pair, even though the edges may
   * not have been inserted consecutively.
   */
  private final @Nullable List<NodeConnection<N>> orderedNodeConnections;

  private int predecessorCount;
  private int successorCount;

  private DirectedGraphConnections(

 * detailed at {@link ImmutableCollection}.
 *
 * <p><b>Grouped iteration.</b> In all current implementations, duplicate elements always appear
 * consecutively when iterating. Elements iterate in order by the <i>first</i> appearance of that
 * element when the multiset was created.
 *
 * <p>See the Guava User Guide article on <a href=

    }

    /**
     * Creates a simple circuit breaker
     *
     * @param name the circuit breaker name
     * @param failureThreshold number of consecutive failures to open circuit
     * @param successThreshold number of successes in half-open to close circuit
     * @param timeoutMillis timeout before attempting to close open circuit
     */

 */
@GwtCompatible
public class Joiner {
  /** Returns a joiner which automatically places {@code separator} between consecutive elements. */
  public static Joiner on(String separator) {
    return new Joiner(separator);
  }

  /** Returns a joiner which automatically places {@code separator} between consecutive elements. */
  public static Joiner on(char separator) {
    return new Joiner(String.valueOf(separator));
  }

                return true;
            }

            // Check if transport is failed
            if (transport.isFailed()) {
                return true;
            }

            // Check for consecutive failures
            String key = getConnectionKey(transport);
            AtomicInteger failures = consecutiveFailures.get(key);
            if (failures != null && failures.get() >= MAX_CONSECUTIVE_FAILURES) {

 */
@GwtCompatible
public class Joiner {
  /** Returns a joiner which automatically places {@code separator} between consecutive elements. */
  public static Joiner on(String separator) {
    return new Joiner(separator);
  }

  /** Returns a joiner which automatically places {@code separator} between consecutive elements. */
  public static Joiner on(char separator) {
    return new Joiner(String.valueOf(separator));
  }

                // Expected
            }
        }

        // Still closed
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());

        // Success resets consecutive failures
        circuitBreaker.call(() -> "success");

        SimpleCircuitBreaker.Statistics stats = circuitBreaker.getStatistics();
        assertEquals(0, stats.consecutiveFailures);

    }

    /**
     * Get failure count for a handle
     *
     * @param handle notification handle
     * @return number of consecutive failures
     */
    private int getFailureCount(ChangeNotificationHandle handle) {
        return failureCounts.getOrDefault(handle.getDirectoryPath(), 0);
    }

    /**

   * int)}, and are subject to all the usual caveats about modification as explained in that API.
   *
   * @param list the list to return consecutive sublists of
   * @param size the desired size of each sublist (the last may be smaller)
   * @return a list of consecutive sublists
   * @throws IllegalArgumentException if {@code partitionSize} is nonpositive
   */

                    log.debug("Error in async notification monitoring for {}: {}", registrationId, e.getMessage());

                    // Exponential backoff on errors: max 30 seconds, based on consecutive failures
                    try {
                        int failures = Math.min(registration.getHeartbeatFailures(), MAX_FAILURE_LIMIT);