String getUrl();

    void setUrl(String url);

    String getParentUrl();

    void setParentUrl(String parentUrl);

    Integer getStatus();

    void setStatus(Integer status);

    Integer getHttpStatusCode();

    void setHttpStatusCode(Integer httpStatusCode);

    String getMethod();

    void setMethod(String method);

    String getMimeType();

   *     {@link Integer#MAX_VALUE} if it is too large, or {@link Integer#MIN_VALUE} if it is too
   *     small
   */
  public static int saturatedCast(long value) {
    if (value > Integer.MAX_VALUE) {
      return Integer.MAX_VALUE;
    }
    if (value < Integer.MIN_VALUE) {
      return Integer.MIN_VALUE;
    }
    return (int) value;
  }

  /**

    }

    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));

  }

  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();

    for (Integer i : IN_ORDER_VALUES) {
      GeneralRange<@Nullable Integer> range = GeneralRange.range(ORDERING, i, CLOSED, i, CLOSED);
      for (Integer j : IN_ORDER_VALUES) {
        assertEquals(Objects.equal(i, j), range.contains(j));
      }
    }
  }

  public void testSingletonRange() {
    GeneralRange<@Nullable Integer> range = GeneralRange.range(ORDERING, 3, CLOSED, 3, CLOSED);
    for (Integer i : IN_ORDER_VALUES) {

    assertMean(0, 0, 0);
    assertMean(-1, -1, -1);
    assertMean(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
    assertMean(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);

    // Exhaustive checks
    for (int x : ALL_INTEGER_CANDIDATES) {
      for (int y : ALL_INTEGER_CANDIDATES) {
        assertMean(x, y);
      }
    }
  }

    ImmutableNetwork.Builder<String, Integer> immutableNetworkBuilder =
        networkBuilder.<String, Integer>immutable();

    // Update NetworkBuilder, but this shouldn't impact immutableNetworkBuilder
    networkBuilder.allowsSelfLoops(false).nodeOrder(ElementOrder.<String>unordered());

    ImmutableNetwork<String, Integer> emptyNetwork = immutableNetworkBuilder.build();

    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 =

    Set<Entry<String, Collection<Integer>>> set =
        newLinkedHashSet(
            asList(
                immutableEntry("foo", (Collection<Integer>) newHashSet(2, 3, 6)),
                immutableEntry("bar", (Collection<Integer>) newHashSet(4, 5, 10, 11)),
                immutableEntry("baz", (Collection<Integer>) newHashSet(7, 8)),
                immutableEntry("dog", (Collection<Integer>) newHashSet(9)),

public class PredicatesTest extends TestCase {
  private static final Predicate<@Nullable Integer> TRUE = Predicates.alwaysTrue();
  private static final Predicate<@Nullable Integer> FALSE = Predicates.alwaysFalse();
  private static final Predicate<@Nullable Integer> NEVER_REACHED =
      new Predicate<@Nullable Integer>() {
        @Override
        public boolean apply(@Nullable Integer i) {