public void testComposeWithLists() {
    Supplier<ArrayList<Integer>> listSupplier =
        new Supplier<ArrayList<Integer>>() {
          @Override
          public ArrayList<Integer> get() {
            return Lists.newArrayList(0);
          }
        };

    Function<List<Integer>, List<Integer>> addElementFunction =
        new Function<List<Integer>, List<Integer>>() {
          @Override

          for (Range<Integer> subRange : RANGES) {
            ImmutableRangeMap<Integer, Integer> rangeMap =
                ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build();

            ImmutableRangeMap.Builder<Integer, Integer> expectedBuilder =
                ImmutableRangeMap.builder();
            for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {

  public void testTransformValues() {
    SetMultimap<String, Integer> multimap =
        ImmutableSetMultimap.of("a", 2, "b", -3, "b", 3, "a", 4, "c", 6);
    Function<Integer, Integer> square =
        new Function<Integer, Integer>() {
          @Override
          public Integer apply(Integer in) {
            return in * in;
          }
        };
    Multimap<String, Integer> transformed = Multimaps.transformValues(multimap, square);

        };

    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().build(loader);

    cache.put(10, 20);

    Map<Integer, Integer> map = cache.getAll(ImmutableList.of(10, 20, 30, 54, 443, 1));

    assertEquals(Integer.valueOf(20), map.get(10));
    assertEquals(Integer.valueOf(0), map.get(20));
    assertEquals(Integer.valueOf(1), map.get(30));
    assertEquals(Integer.valueOf(2), map.get(54));

  private UnsignedInts() {}

  static int flip(int value) {
    return value ^ Integer.MIN_VALUE;
  }

  /**
   * Compares the two specified {@code int} values, treating them as unsigned values between {@code
   * 0} and {@code 2^32 - 1} inclusive.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#compareUnsigned(int, int)} instead.
   *
   * @param a the first unsigned {@code int} to compare

    ValueGraph<String, Integer> graph1 =
        ImmutableValueGraph.copyOf(ValueGraphBuilder.directed().<String, Integer>build());
    ValueGraph<String, Integer> graph2 = ImmutableValueGraph.copyOf(graph1);

    assertThat(graph2).isSameInstanceAs(graph1);
  }

  @Test
  public void incidentEdgeOrder_stable() {
    ImmutableValueGraph<String, Integer> immutableValueGraph =

    }

    assertEquals(Integer.valueOf(0), cache.getUnchecked(0));
    assertEquals(Integer.valueOf(1), cache.getUnchecked(1));
    assertEquals(Integer.valueOf(2), cache.getUnchecked(2));
    assertEquals(expectedLoads, loader.getLoadCount());
    assertEquals(expectedReloads, loader.getReloadCount());

    // refresh 0
    ticker.advance(1, MILLISECONDS);
    assertEquals(Integer.valueOf(1), cache.getUnchecked(0));

  }

  public void testOfEntriesNull() {
    Entry<@Nullable Integer, Integer> nullKey = entry(null, 23);
    try {
      ImmutableBiMap.ofEntries((Entry<Integer, Integer>) nullKey);
      fail();
    } catch (NullPointerException expected) {
    }
    Entry<Integer, @Nullable Integer> nullValue =
        ImmutableBiMapTest.<@Nullable Integer>entry(23, null);
    try {

  }

  public void testMissingException() {
    List<Integer> emptyList = newArrayList();

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            1, MODIFIABLE, emptyList, IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {
            return new Iterator<Integer>() {
              @Override
              public void remove() {

    assertEquals((Integer) 30, it.next());
    assertEquals((Integer) 40, it.next());
    // Skipping 20
    assertEquals((Integer) 11, it.next());
    // Not skipping 400, because it moved back down
    assertEquals((Integer) 400, it.next());
    assertEquals((Integer) 13, it.next());
    assertEquals((Integer) 200, it.next());
    assertEquals((Integer) 300, it.next());
    // Last from forgetMeNot.