throws ExecutionException {

    repeatedlyInterruptTestThread(100, tearDownStack);

    assertThrows(
        TimeoutException.class,
        () -> getUninterruptibly(delayedFuture, 500, TimeUnit.MILLISECONDS));
    assertTrue(Thread.interrupted()); // clears the interrupt state, too

    assertFalse(sleeper.completed);
    assertTrue(getUninterruptibly(delayedFuture));

          builder.put(element, element);
        }
        return builder.build();
      }
    };

    abstract Map<Element, Element> create(Collection<Element> contents);
  }

  @Param({"5", "50", "500", "5000", "50000"})
  private int size;

  // TODO: look at exact (==) hits vs. equals() hits?
  @Param("0.9")
  private double hitRate;

  @Param("true")
  private boolean isUserTypeFast;

            }

            final Map<String, String> infoMap = crawlingInfoHelper.getInfoMap(options.sessionId);

            final StringBuilder buf = new StringBuilder(500);
            for (final Map.Entry<String, String> entry : infoMap.entrySet()) {
                if (buf.length() != 0) {
                    buf.append(',');
                }

                return 200;
            }
        };
        indexingHelper.setMaxRetryCount(5);
        indexingHelper.setDefaultRowSize(100);
        indexingHelper.setRequestInterval(500);
        ComponentUtil.register(indexingHelper, "indexingHelper");
        ComponentUtil.register(new ThumbnailManager(), "thumbnailManager");
        final CrawlingConfigHelper crawlingConfigHelper = new CrawlingConfigHelper();

      String value = String.valueOf(i);
      builder.put(key, value);
      expected.put(key, value);
    }
    ImmutableMap<Integer, String> map = builder.buildKeepingLast();
    assertThat(map).hasSize(500);
    assertThat(map).containsExactlyEntriesIn(expected).inOrder();
  }

  // This method tests the int case.
  public void testBuildKeepingLast_bigTable() {

            return new String(new char[50_000]);
          }
        };
    List<Object> list = Collections.singletonList(object);
    for (int i = 0; i < 10; i++) {
      Object[] array = new Object[500];
      Arrays.fill(array, list);
      list = Arrays.asList(array);
    }
    future2.set(list);

    unused = future.toString();
  }

  public void testToString_notDone() throws Exception {

      String value = String.valueOf(i);
      builder.put(key, value);
      expected.put(key, value);
    }
    ImmutableMap<Integer, String> map = builder.buildKeepingLast();
    assertThat(map).hasSize(500);
    assertThat(map).containsExactlyEntriesIn(expected).inOrder();
  }

  // This method tests the int case.
  public void testBuildKeepingLast_bigTable() {

            return new String(new char[50_000]);
          }
        };
    List<Object> list = Collections.singletonList(object);
    for (int i = 0; i < 10; i++) {
      Object[] array = new Object[500];
      Arrays.fill(array, list);
      list = Arrays.asList(array);
    }
    future2.set(list);

    unused = future.toString();
  }

  public void testToString_notDone() throws Exception {

  public void testCancellingAllDelegatesIsNotQuadratic() throws Exception {
    ImmutableList.Builder<SettableFuture<Long>> builder = ImmutableList.builder();
    for (int i = 0; i < 500_000; i++) {
      builder.add(SettableFuture.<Long>create());
    }
    ImmutableList<SettableFuture<Long>> inputs = builder.build();
    ImmutableList<ListenableFuture<Long>> delegates = inCompletionOrder(inputs);

      ticker.advance(10, MILLISECONDS); // so that the next call will trigger refresh
      assertThat(cache.getOrLoad("test")).isEqualTo("testLoad");
      reloadStarted.await();
      ticker.advance(500, MILLISECONDS); // so that the entry expires during the reload
      threadAboutToBlockForRefresh.set(Thread.currentThread());
      assertThat(cache.getOrLoad("test")).isEqualTo("testReload");
    } finally {