// return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(ImmutableIntArray.of())
        .addEqualityGroup(
            ImmutableIntArray.of(1, 2),
            reserialize(ImmutableIntArray.of(1, 2)),

   *     or if the hashcodes are different.
   */
  @CanIgnoreReturnValue
  public static <T> T reserializeAndAssert(T object) {
    T copy = reserialize(object);
    new EqualsTester().addEqualityGroup(object, copy).testEquals();
    Assert.assertEquals(object.getClass(), copy.getClass());
    return copy;
  }

    assertEquals(rangeMap.asMapOfRanges(), copy.asMapOfRanges());
  }

  // Overriding testEquals because it seems that we get spurious failures when it things empty
  // should be unequal to empty.
  public void testEquals() {
    TreeRangeMap<Integer, Integer> empty = TreeRangeMap.create();
    TreeRangeMap<Integer, Integer> nonEmpty = TreeRangeMap.create();

    // return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(ImmutableDoubleArray.of())
        .addEqualityGroup(
            ImmutableDoubleArray.of(1, 2),
            reserialize(ImmutableDoubleArray.of(1, 2)),

    Set<Entry<String, Integer>> entrySet = map.entrySet();
    assertTrue(entrySet instanceof SynchronizedSet);
    assertSame(mutex, ((SynchronizedSet<?>) entrySet).mutex);
  }

  public void testEquals() {
    boolean unused = create().equals(new HashMap<String, Integer>());
  }

  public void testHashCode() {
    int unused = create().hashCode();
  }

  public void testToString() {

        .addEqualityGroup(parse("softValues"), parse("softValues"))
        .addEqualityGroup(parse("weakValues"), parse("weakValues"))
        .addEqualityGroup(parse("recordStats"), parse("recordStats"))
        .testEquals();
  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testMaximumWeight_withWeigher() {
    CacheBuilder<Object, Object> builder = CacheBuilder.from(parse("maximumWeight=9000"));

        assertEquals("3", false, StringUtil.contains("abc", "d"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testEquals() throws Exception {
        assertEquals("1", true, StringUtil.equals("a", "a"));
        assertEquals("2", true, StringUtil.equals(null, null));
        assertEquals("3", false, StringUtil.equals("a", null));

    for (Integer node : graph.nodes()) {
      new EqualsTester()
          .addEqualityGroup(
              graph.predecessors(node), graph.successors(node), graph.adjacentNodes(node))
          .testEquals();
    }
  }

  @Override
  @Test
  public void nodes_checkReturnedSetMutability() {
    assume().that(graphIsMutable()).isTrue();

    Set<Integer> nodes = graph.nodes();

    // return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(ImmutableDoubleArray.of())
        .addEqualityGroup(
            ImmutableDoubleArray.of(1, 2),
            reserialize(ImmutableDoubleArray.of(1, 2)),

          if (EVEN.apply(i)) {
            expected.add(i);
          }
        }
        new EqualsTester()
            .addEqualityGroup(expected, filter(createUnfiltered(contents), EVEN))
            .testEquals();
      }
    }
  }

  public abstract static class AbstractFilteredSortedSetTest<C extends SortedSet<Integer>>
      extends AbstractFilteredSetTest<C> {
    public void testFirst() {