}

  private static void insertIntoReplica(Map<Integer, AtomicInteger> replica, int newValue) {
    if (replica.containsKey(newValue)) {
      replica.get(newValue).incrementAndGet();
    } else {
      replica.put(newValue, new AtomicInteger(1));
    }
  }

  private static void removeMinFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int minValue) {
    Integer replicatedMinValue = replica.firstKey();

  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  private void testSupplierThreadSafe(Function<Supplier<Boolean>, Supplier<Boolean>> memoizer)
      throws Throwable {
    AtomicInteger count = new AtomicInteger(0);
    AtomicReference<Throwable> thrown = new AtomicReference<>(null);
    int numThreads = 3;
    Thread[] threads = new Thread[numThreads];
    long timeout = SECONDS.toNanos(60);

  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  private void testSupplierThreadSafe(Function<Supplier<Boolean>, Supplier<Boolean>> memoizer)
      throws Throwable {
    AtomicInteger count = new AtomicInteger(0);
    AtomicReference<Throwable> thrown = new AtomicReference<>(null);
    int numThreads = 3;
    Thread[] threads = new Thread[numThreads];
    long timeout = SECONDS.toNanos(60);

    assertThat(stats.loadExceptionCount()).isEqualTo(1);
    assertThat(stats.hitCount()).isEqualTo(0);
  }

  public void testReloadAfterFailure() throws ExecutionException {
    AtomicInteger count = new AtomicInteger();
    Exception e = new IllegalStateException("exception to trigger failure on first load()");
    CacheLoader<Integer, String> failOnceFunction =
        new CacheLoader<Integer, String>() {

        int threadCount = 10;
        int operationsPerThread = 50;
        CountDownLatch latch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;

            NUM_THREADS,
            Long.MAX_VALUE,
            SECONDS,
            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    AtomicInteger integer = new AtomicInteger();
    // Execute a bunch of tasks to ensure that our threads are allocated and hot
    for (int i = 0; i < NUM_THREADS * 10; i++) {

  private static class WildcardCapturer {

    static final WildcardCapturer INSTANCE = new WildcardCapturer();

    private final AtomicInteger id;

    private WildcardCapturer() {
      this(new AtomicInteger());
    }

    private WildcardCapturer(AtomicInteger id) {
      this.id = id;
    }

    final Type capture(Type type) {
      checkNotNull(type);
      if (type instanceof Class) {

    assertThat(stats.loadExceptionCount()).isEqualTo(1);
    assertThat(stats.hitCount()).isEqualTo(0);
  }

  public void testReloadAfterFailure() throws ExecutionException {
    AtomicInteger count = new AtomicInteger();
    Exception e = new IllegalStateException("exception to trigger failure on first load()");
    CacheLoader<Integer, String> failOnceFunction =
        new CacheLoader<Integer, String>() {

import java.net.Socket
import java.net.SocketException
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
import java.util.logging.Level
import java.util.logging.Logger
import okhttp3.TestUtil.threadFactory
import okhttp3.internal.and
import okhttp3.internal.closeQuietly
import okhttp3.internal.threadName

        final int operationsPerThread = 100;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);
        final AtomicInteger errorCount = new AtomicInteger(0);

        testTransformer.setName("concurrentName");

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int i = 0; i < threadCount; i++) {