ContiguousSet.create(Range.atLeast(Integer.MIN_VALUE), integers()));
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.atMost(Integer.MAX_VALUE), integers()));
  }

  @GwtIncompatible // SerializableTester
  public void testSerialization() {

    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(0, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(1, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE,
        ImmutableCollection.Builder.expandedCapacity(Integer.MAX_VALUE - 1, Integer.MAX_VALUE));

        }
        if (i2 == -1) {
            // first one is known, so it comes first
            return -1;
        }
        int rv = Integer.compare(i1, i2);
        if (rv != 0) {
            return rv;
        }
        // same execution point, now compare priorities
        return Integer.compare(p1.priority(), p2.priority());
    }

                                "application/json": {
                                    "schema": {
                                        "title": "Response 500 Valid1 Valid1 Get",
                                        "type": "integer",
                                    }
                                }
                            },
                        },
                    },
                }
            },
            "/valid2": {

                    "parameters": [
                        {
                            "required": True,
                            "schema": {"title": "User Id", "type": "integer"},
                            "name": "user_id",
                            "in": "path",
                        },
                        {
                            "required": True,

  }

  public void testFailed() throws Exception {
    Exception e = new Exception();
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                throw e;
              }
            });
    task.run();
    assertTrue(task.isDone());

        .plus(String::class, "hello")
        .plus(Integer::class, 5 as Integer)
    assertThat(tags[String::class]).isEqualTo("hello")
    assertThat(tags[Integer::class]).isEqualTo(5)
  }

  /** The implementation retains no nodes from the original linked list. */
  @Test
  fun replaceFirstElement() {
    val tags =
      EmptyTags
        .plus(String::class, "a")
        .plus(Integer::class, 5 as Integer)

  }

  // TODO(b/172823566): Use mainline testToImmutableSetMultimap once CollectorTester is usable.
  public void testToImmutableSetMultimap_java7_combine() {
    ImmutableSetMultimap.Builder<String, Integer> zis =
        ImmutableSetMultimap.<String, Integer>builder().put("a", 1).put("b", 2);
    ImmutableSetMultimap.Builder<String, Integer> zat =

      extends TestFilteredMultimapGenerator<SetMultimap<String, Integer>>
      implements TestSetMultimapGenerator<String, Integer> {

    abstract SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap);

    @Override
    public SetMultimap<String, Integer> create(Object... elements) {
      SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
      for (Object o : elements) {

  }

  private Multimap<String, Integer> createMultimap() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();
    unfiltered.put("zero", 55556);
    unfiltered.put("one", 55556);
    unfiltered.put("badkey", 1);
    return Multimaps.filterEntries(unfiltered, PREDICATE);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    Multimap<String, Integer> multimap = createMultimap();