while (true) {
      AtomicInteger existingCounter = safeGet(countMap, element);
      if (existingCounter == null) {
        existingCounter = countMap.putIfAbsent(element, new AtomicInteger(occurrences));
        if (existingCounter == null) {
          return 0;
        }
        // existingCounter != null: fall through to operate against the existing AtomicInteger
      }

      while (true) {

   */
  public void testAdd_withFailures() {
    AtomicInteger existing = new AtomicInteger(12);
    AtomicInteger existingZero = new AtomicInteger(0);

    // initial map.get()
    when(backingMap.get(KEY)).thenReturn(null);
    // since get returned null, try a putIfAbsent; that fails due to a simulated race
    when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(existingZero);

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, SECONDS));
  }

  public void testExecute_idempotent() {
    AtomicInteger runCalled = new AtomicInteger();
    list.add(runCalled::getAndIncrement, directExecutor());
    list.execute();
    assertEquals(1, runCalled.get());
    list.execute();
    assertEquals(1, runCalled.get());
  }

    @Test
    public void test_mixedCallbacks_onlyThenInvokedOnResolve() throws Exception {
        final Deferred<SuggestResponse> deferred = new Deferred<>();
        final AtomicInteger thenCount = new AtomicInteger(0);
        final AtomicInteger errorCount = new AtomicInteger(0);
        final CountDownLatch latch = new CountDownLatch(1);

        deferred.promise().then(response -> {
            thenCount.incrementAndGet();

            // Expected behavior
        }
    }

    @Test
    public void test_processThreadDump_multipleThreads() {
        AtomicInteger threadCount = new AtomicInteger(0);
        AtomicInteger stackTraceCount = new AtomicInteger(0);

        Consumer<String> countingConsumer = line -> {
            if (line.startsWith("Thread:")) {
                threadCount.incrementAndGet();

    volatile boolean startUpCalled = false;
    volatile boolean shutDownCalled = false;
    final AtomicInteger numberOfTimesRunCalled = new AtomicInteger(0);
    final AtomicInteger numberOfTimesExecutorCalled = new AtomicInteger(0);
    final AtomicInteger numberOfTimesSchedulerCalled = new AtomicInteger(0);
    volatile @Nullable Exception runException = null;
    volatile @Nullable Exception startUpException = null;

    volatile boolean startUpCalled = false;
    volatile boolean shutDownCalled = false;
    final AtomicInteger numberOfTimesRunCalled = new AtomicInteger(0);
    final AtomicInteger numberOfTimesExecutorCalled = new AtomicInteger(0);
    final AtomicInteger numberOfTimesSchedulerCalled = new AtomicInteger(0);
    volatile @Nullable Exception runException = null;
    volatile @Nullable Exception startUpException = null;

  }

  public void testConstructingWithNullExecutor_fails() {
    assertThrows(NullPointerException.class, () -> new SequentialExecutor(null));
  }

  public void testBasics() {
    AtomicInteger totalCalls = new AtomicInteger();
    Runnable intCounter =
        () -> {
          totalCalls.incrementAndGet();
          // Make sure that no other tasks are scheduled to run while this is running.

    while (true) {
      AtomicInteger existingCounter = safeGet(countMap, element);
      if (existingCounter == null) {
        existingCounter = countMap.putIfAbsent(element, new AtomicInteger(occurrences));
        if (existingCounter == null) {
          return 0;
        }
        // existingCounter != null: fall through to operate against the existing AtomicInteger
      }

      while (true) {

    }

    private void runNext() {
      tasks.removeFirst().run();
    }
  }

  public void testAsyncReload() throws Exception {
    AtomicInteger loadCount = new AtomicInteger();
    AtomicInteger reloadCount = new AtomicInteger();
    AtomicInteger loadAllCount = new AtomicInteger();

    CacheLoader<Object, Object> baseLoader =
        new CacheLoader<Object, Object>() {
          @Override