if (!leakDetectionEnabled) {
            return;
        }

        // Process phantom references to detect leaks
        Reference<?> ref;
        while ((ref = referenceQueue.poll()) != null) {
            handlePhantomReference(ref);
        }

        // Check for old unclosed resources
        long now = System.currentTimeMillis();

    }

    // ===================================================================================
    //                                                                           Roll-back
    //                                                                           =========
    @Override
    public void rollback() {
        for (MultipartFormFile formFile : elementsFile.values()) {

                    [ -e "$t" ] ;;                      #(
              *)    false ;;
            esac
        then
            arg=$( cygpath --path --ignore --mixed "$arg" )
        fi
        # Roll the args list around exactly as many times as the number of
        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #

        clearValueReferenceQueue();
      }
    }

    void clearKeyReferenceQueue() {
      while (keyReferenceQueue.poll() != null) {}
    }

    void clearValueReferenceQueue() {
      while (valueReferenceQueue.poll() != null) {}
    }

    // recency queue, shared by expiration and eviction

    /**

            }
        }
    }

    static MyToken getNextUniqueToken(final PriorityQueue<MyToken> que, final MyToken prev) {
        while (true) {
            final MyToken token = que.poll();
            if (token == null) {
                return null;
            }
            if (prev == null || !prev.identical(token)) {
                return token;
            }
        }
    }

  }

  private static <K, V> void assertNotificationEnqueued(LocalCache<K, V> map, K key, V value) {
    RemovalNotification<K, V> notification = map.removalNotificationQueue.poll();
    assertThat(notification.getKey()).isSameInstanceAs(key);
    assertThat(notification.getValue()).isSameInstanceAs(value);
  }

  // Segment eviction tests

  }

  private static <K, V> void assertNotificationEnqueued(LocalCache<K, V> map, K key, V value) {
    RemovalNotification<K, V> notification = map.removalNotificationQueue.poll();
    assertThat(notification.getKey()).isSameInstanceAs(key);
    assertThat(notification.getValue()).isSameInstanceAs(value);
  }

  // Segment eviction tests

      // If even the first one wasn't there, clean up so that the next test doesn't see an element.
      producerThread.cancel(true);
      producer.doneProducing.await();
      if (drained == 0) {
        q.poll(); // not necessarily there if producer was interrupted
      }
    }
  }

  public void testDrainOverflow() throws InterruptedException {

    void execute() {
      synchronized (runnables) {
        if (executed) {
          return;
        }
        executed = true;
      }

      while (!runnables.isEmpty()) {
        runnables.poll().execute();
      }
    }

    private static class RunnableExecutorPair {
      final Runnable runnable;
      final Executor executor;

      RunnableExecutorPair(Runnable runnable, Executor executor) {

  }

  void checkEmpty(BlockingQueue<?> q) {
    try {
      assertTrue(q.isEmpty());
      assertEquals(0, q.size());
      assertThat(q.peek()).isNull();
      assertThat(q.poll()).isNull();
      assertThat(q.poll(0, MILLISECONDS)).isNull();
      assertEquals("[]", q.toString());
      assertThat(q.toArray()).isEmpty();
      assertFalse(q.iterator().hasNext());
      try {
        q.element();