*
 * See [RFC 7234, 5.2](https://tools.ietf.org/html/rfc7234#section-5.2).
 */
class CacheControl internal constructor(
  /**
   * In a response, this field's name "no-cache" is misleading. It doesn't prevent us from caching
   * the response; it only means we have to validate the response with the origin server before
   * returning it. We can do this with a conditional GET.
   *
   * In a request, it means do not use a cache to satisfy the request.

    private static final Logger log = LoggerFactory.getLogger(SimpleCircuitBreaker.class);

    /**
     * Circuit breaker states
     */
    public enum State {
        CLOSED, // Normal operation
        OPEN, // Failing, requests blocked
        HALF_OPEN // Testing recovery
    }

    private final String name;
    private final AtomicReference<State> state = new AtomicReference<>(State.CLOSED);

 * <li>Download and Cache: If Maven finds the artifact in a remote repository, it downloads it and stores it in the local repository for future use.</li>
 * </ol>
 * <p>By caching artifacts in the local repository, Maven minimizes the need to repeatedly download the same artifacts, thus optimizing the build process.</p>
 *
 * <h3>Projects</h3>
 *

 * It uses XPath expressions to extract text content from HTML documents.
 * <p>
 * This class provides methods to configure the XPath expressions, parser features, and properties.
 * It also includes caching mechanism for XPathAPI instances to improve performance.
 * </p>
 * <p>
 * The extracted text is obtained from the nodes selected by the {@code targetNodePath} XPath expression.

        if (i == BLOCK_LENGTH - 1) {
            transform(buffer, 0);
        }
    }

    /**
     * MD4 block update operation.
     * <p>
     * Continues an MD4 message digest operation, by filling the buffer,
     * transform(ing) data in 512-bit message block(s), updating the variables
     * context and count, and leaving (buffering) the remaining bytes in buffer
     * for the next update or finish.
     *

        assertEquals(3, circuitBreaker.getFailureCount(), "Failure count should be at threshold");
    }

    @Test
    public void testOpenCircuitBlocksRequests() {
        // Open the circuit by causing failures
        for (int i = 0; i < 3; i++) {
            try {
                circuitBreaker.executeWithCircuitBreaker(() -> {
                    throw new RuntimeException("Test failure");
                });

import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.SocketEffect.ShutdownConnection
import mockwebserver3.SocketEffect.Stall
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CallEnd
import okhttp3.CallEvent.ConnectStart
import okhttp3.CallEvent.ConnectionAcquired
import okhttp3.CallEvent.ConnectionReleased
import okhttp3.CallEvent.ResponseFailed
import okhttp3.CallEvent.RetryDecision

    while (iterator.hasNext()) {
      E higher = iterator.next();
      if (comparator().compare(e, higher) < 0) {
        return higher;
      }
    }
    return null;
  }

  public @Nullable E ceiling(E e) {
    ImmutableSortedSet<E> set = tailSet(e, true);
    return !set.isEmpty() ? set.first() : null;
  }

  public @Nullable E floor(E e) {
    ImmutableSortedSet<E> set = headSet(e, true);

  }

  @Override
  public boolean equals(@Nullable Object object) {
    return Maps.equalsImpl(this, object);
  }

  @Override
  public int hashCode() {
    // not caching hash code since it could change if map values are mutable
    // in a way that modifies their hash codes
    return entrySet().hashCode();
  }

  @Override
  public String toString() {

    // The leftmost position at which the greatest of the k lower elements
    // -- the new value of threshold -- might be found.

    int iterations = 0;
    int maxIterations = IntMath.log2(right - left, RoundingMode.CEILING) * 3;
    while (left < right) {
      int pivotIndex = (left + right + 1) >>> 1;

      int pivotNewIndex = partition(left, right, pivotIndex);

      if (pivotNewIndex > k) {