println("\n\nRequest to ${server1.socketAddress}")
    executeSynchronously(request)
      .assertSuccessful()
      .assertCode(200)

    println("server1.requestCount ${server1.requestCount}")
    assertThat(server1.requestCount).isEqualTo(1)

    // Close the proxy server
    if (cleanClose) {
      server1.close()
    }

    // Now redirect with DNS to proxyServer2

   * missRate =~ 1.0}.
   */
  public double hitRate() {
    long requestCount = requestCount();
    return (requestCount == 0) ? 1.0 : (double) hitCount / requestCount;
  }

  /**
   * Returns the number of times {@link Cache} lookup methods have returned an uncached (newly
   * loaded) value, or null. Multiple concurrent calls to {@link Cache} lookup methods on an absent

   * missRate =~ 1.0}.
   */
  public double hitRate() {
    long requestCount = requestCount();
    return (requestCount == 0) ? 1.0 : (double) hitCount / requestCount;
  }

  /**
   * Returns the number of times {@link Cache} lookup methods have returned an uncached (newly
   * loaded) value, or null. Multiple concurrent calls to {@link Cache} lookup methods on an absent

    CacheStats stats = counter.snapshot();
    int requestCount = 11 + 23;
    assertThat(stats.requestCount()).isEqualTo(requestCount);
    assertThat(stats.hitCount()).isEqualTo(11);
    assertThat(stats.hitRate()).isEqualTo(11.0 / requestCount);
    int missCount = 23;
    assertThat(stats.missCount()).isEqualTo(missCount);
    assertThat(stats.missRate()).isEqualTo(((double) missCount) / requestCount);

import okhttp3.Protocol
import org.junit.rules.ExternalResource

class MockWebServer :
  ExternalResource(),
  Closeable {
  val delegate = mockwebserver3.MockWebServer()

  val requestCount: Int by delegate::requestCount

  var bodyLimit: Long by delegate::bodyLimit

  var serverSocketFactory: ServerSocketFactory? by delegate::serverSocketFactory

  var dispatcher: Dispatcher = QueueDispatcher()
    set(value) {

    hitCount++
  }

  @Synchronized fun networkCount(): Int = networkCount

  @Synchronized fun hitCount(): Int = hitCount

  @Synchronized fun requestCount(): Int = requestCount

  private inner class RealCacheRequest(
    private val editor: DiskLruCache.Editor,
  ) : CacheRequest {
    private val cacheOut: Sink = editor.newSink(ENTRY_BODY)
    private val body: Sink

            }

            public synchronized void recordFailure() {
                requestCount++;
                failureCount++;
                lastUpdateTime = System.currentTimeMillis();
            }

            public synchronized void reset(long timestamp) {
                requestCount = 0;
                failureCount = 0;
                totalResponseTime = 0;

	inShutdown    uint32        // indicates whether the server is in shutdown or not
	requestCount  int32         // counter holds no. of request in progress.
}

// GetRequestCount - returns number of request in progress.
func (srv *Server) GetRequestCount() int {
	return int(atomic.LoadInt32(&srv.requestCount))
}

// Init - init HTTP server

        }

        if (count > maxRequests) {
            blockedIps.put(ip, Boolean.TRUE);
            logger.info("Rate limit exceeded, IP blocked: ip={}, requestCount={}", ip, count);
            return false;
        }

        return true;
    }

    /**
     * Get the Retry-After header value in seconds.
     * @return the retry after seconds
     */

    cache.flush()
    cache.close()
    val directory: File = cache.directory
    val networkCount: Int = cache.networkCount()
    val hitCount: Int = cache.hitCount()
    val requestCount: Int = cache.requestCount()
  }

  @Test
  fun cacheControl() {
    val cacheControl: CacheControl = CacheControl.Builder().build()
    val noCache: Boolean = cacheControl.noCache