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

        assertEquals("RUNNING", CrawlerStatus.RUNNING.toString());
        assertEquals("DONE", CrawlerStatus.DONE.toString());
    }

    /**
     * Test equals method
     */
    public void test_equals() {
        // Same instance
        assertTrue(CrawlerStatus.INITIALIZING.equals(CrawlerStatus.INITIALIZING));
        assertTrue(CrawlerStatus.RUNNING.equals(CrawlerStatus.RUNNING));

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

        .addEqualityGroup(new TypeToken<List<Integer>>() {}.method(setMethod))
        .addEqualityGroup(new TypeToken<List<String>>() {}.method(setMethod))
        .testEquals();
  }

  private interface Loser<E extends Throwable> {
    void lose() throws E;
  }

  public <T extends Loser<AssertionError>> void testMethod_exceptionTypes()

        assertFalse(tree.matches("otherShare", "testService"));

        // Test non-matching service
        assertFalse(tree.matches("testShare", "otherService"));
    }

    @Test
    void testEquals() {
        SmbTree tree1 = new SmbTree(session, "testShare", "testService");
        SmbTree tree2 = new SmbTree(session, "testShare", "testService");
        SmbTree tree3 = new SmbTree(session, "otherShare", "testService");

    oos.writeObject(keySet);
    oos.writeObject(values);
    oos.close();

    int finalSize = bytes.size();

    assertThat(finalSize - mapSize).isLessThan(100);
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(
            ImmutableMap.of(),
            ImmutableMap.builder().buildOrThrow(),
            ImmutableMap.ofEntries(),
            map())

public class PrunedTagTest extends UnitFessTestCase {

    public void test_hashCode() {
        PrunedTag prunedtag = new PrunedTag("tag");

        assertTrue(prunedtag.hashCode() >= 0);

    }

    public void test_equals() {

        PrunedTag prunedtag = new PrunedTag("tag");

        assertTrue(prunedtag.equals(prunedtag));
        assertEquals(false, prunedtag.equals(null));
        assertEquals(false, prunedtag.equals(""));

        .addEqualityGroup(new TypeToken<List<Integer>>() {}.method(setMethod))
        .addEqualityGroup(new TypeToken<List<String>>() {}.method(setMethod))
        .testEquals();
  }

  private interface Loser<E extends Throwable> {
    void lose() throws E;
  }

  public <T extends Loser<AssertionError>> void testMethod_exceptionTypes()

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