assertEquals(EMPTY, diff.entriesOnlyOnLeft());
    assertEquals(EMPTY, diff.entriesOnlyOnRight());
    assertEquals(EMPTY, diff.entriesInCommon());
    assertEquals(EMPTY, diff.entriesDiffering());
    assertEquals("equal", diff.toString());
  }

  public void testMapDifferenceEmptySingleton() {
    MapDifference<Integer, Integer> diff = Maps.difference(EMPTY, SINGLETON);
    assertFalse(diff.areEqual());

   * first permutation will be in ascending order, and the last will be in descending order.
   *
   * <p>Elements that compare equal are considered equal and no new permutations are created by
   * swapping them.
   *
   * <p>An empty iterable has only one permutation, which is an empty list.
   *

        new Relocation().equals(new Relocation());
    }

    @Test
    void testEqualsIdentity() {
        Relocation thing = new Relocation();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Relocation().toString());
    }

        new Contributor().equals(new Contributor());
    }

    @Test
    void testEqualsIdentity() {
        Contributor thing = new Contributor();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Contributor().toString());
    }

        new Extension().equals(new Extension());
    }

    @Test
    void testEqualsIdentity() {
        Extension thing = new Extension();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Extension().toString());
    }

    }

    @Test
    void testEqualsIdentity() {
        PluginContainer thing = new PluginContainer();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new PluginContainer().toString());
    }

        new Dependency().equals(new Dependency());
    }

    @Test
    void testEqualsIdentity() {
        Dependency thing = new Dependency();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Dependency().toString());
    }

    }

    @Test
    void testEqualsIdentity() {
        DistributionManagement thing = new DistributionManagement();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new DistributionManagement().toString());
    }

        new Exclusion().equals(new Exclusion());
    }

    @Test
    void testEqualsIdentity() {
        Exclusion thing = new Exclusion();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Exclusion().toString());
    }

        new Plugin().equals(new Plugin());
    }

    @Test
    void testEqualsIdentity() {
        Plugin thing = new Plugin();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Plugin().toString());
    }