long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);
    for (int i = 0; i < reps; i++) {
      final Facade<Integer> localFuture = impl.newFacade();
      list.add(localFuture);
      localFuture.setException(exception);
    }
    for (int i = 0; i < reps; i++) {
      Facade<Integer> facade = list.get(i);
      try {
        facade.get();
        r++;

public final class IterablesFilterArrayListTest
    extends AbstractFilteredIterableTest<Iterable<Integer>> {
  @Override
  Iterable<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Iterable<Integer> filter(Iterable<Integer> elements, Predicate<? super Integer> predicate) {
    return Iterables.filter(elements, predicate);
  }

    testGraphMutation(GraphBuilder.undirected());
  }

  private static void testGraphMutation(GraphBuilder<? super Integer> graphBuilder) {
    Random gen = new Random(42); // Fixed seed so test results are deterministic.

    for (int trial = 0; trial < NUM_TRIALS; ++trial) {
      MutableGraph<Integer> graph = graphBuilder.allowsSelfLoops(true).build();

      assertThat(graph.nodes()).isEmpty();

    return suite;
  }

  public void testInsertionOrder() {
    Map<Integer, String> map = CompactLinkedHashMap.create();
    map.put(1, "a");
    map.put(4, "b");
    map.put(3, "d");
    map.put(2, "c");
    testHasMapEntriesInOrder(map, 1, "a", 4, "b", 3, "d", 2, "c");
  }

  public void testInsertionOrderAfterPutKeyTwice() {
    Map<Integer, String> map = CompactLinkedHashMap.create();
    map.put(1, "a");

public final class Collections2FilterArrayListTest
    extends AbstractFilteredCollectionTest<Collection<Integer>> {
  @Override
  Collection<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Collection<Integer> filter(Collection<Integer> elements, Predicate<? super Integer> predicate) {
    return Collections2.filter(elements, predicate);
  }

        or "'loc': ('path', 'item_id')" in response.text
    )
    assert (
        # TODO: remove when deprecating Pydantic v1
        "value is not a valid integer" in response.text
        or "Input should be a valid integer, unable to parse string as an integer"
        in response.text
    )


def test_get_http_error():
    response = client.get("/items/3")
    assert response.status_code == 418, response.text

  public SubMapMultimapAsMapImplementsMapTest() {
    super(true, true, true);
  }

  private TreeMultimap<String, Integer> createMultimap() {
    TreeMultimap<String, Integer> multimap =
        TreeMultimap.create(
            Ordering.<String>natural().nullsFirst(), Ordering.<Integer>natural().nullsFirst());
    multimap.put("a", -1);
    multimap.put("a", -3);
    multimap.put("z", -2);
    return multimap;
  }

  }

  private static Function<Integer, Integer> add(final int delta) {
    return new Function<Integer, Integer>() {
      @Override
      public Integer apply(Integer input) {
        return input + delta;
      }
    };
  }

  private static AsyncCallable<Integer> asyncAdd(
      final ListenableFuture<Integer> future, final int delta, final Executor executor) {

  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableUndirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.incidentEdgeOrder = incidentEdgeOrder;
  }

  @Override
  public MutableGraph<Integer> createGraph() {
    return GraphBuilder.undirected()

      "term": {
        "type": "keyword"
      },
      "content": {
        "type": "keyword"
      },
      "virtualHost": {
        "type": "keyword"
      },
      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {