Multimap<Integer, String> map1 = ImmutableMultimap.of(1, "one");
    Multimap<Integer, String> map2 = ImmutableMultimap.of(2, "two");
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> Multimap<K, V> wrap(final Multimap<K, V> delegate) {
    return new ForwardingMultimap<K, V>() {
      @Override

  }

  public void testOfInstance_equals() {
    new EqualsTester()
        .addEqualityGroup(Suppliers.ofInstance("foo"), Suppliers.ofInstance("foo"))
        .addEqualityGroup(Suppliers.ofInstance("bar"))
        .testEquals();
  }

  public void testCompose_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")),

  }

  public void testOfInstance_equals() {
    new EqualsTester()
        .addEqualityGroup(Suppliers.ofInstance("foo"), Suppliers.ofInstance("foo"))
        .addEqualityGroup(Suppliers.ofInstance("bar"))
        .testEquals();
  }

  public void testCompose_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")),

    ListMultimap<Integer, String> map1 = ImmutableListMultimap.of(1, "one");
    ListMultimap<Integer, String> map2 = ImmutableListMultimap.of(2, "two");
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> ListMultimap<K, V> wrap(final ListMultimap<K, V> delegate) {
    return new ForwardingListMultimap<K, V>() {

    Table<Integer, Integer, String> table1 = ImmutableTable.of(1, 1, "one");
    Table<Integer, Integer, String> table2 = ImmutableTable.of(2, 2, "two");
    new EqualsTester()
        .addEqualityGroup(table1, wrap(table1), wrap(table1))
        .addEqualityGroup(table2, wrap(table2))
        .testEquals();
  }

  private static <R, C, V> Table<R, C, V> wrap(final Table<R, C, V> delegate) {
    return new ForwardingTable<R, C, V>() {

    SortedSetMultimap<Integer, String> map2 = TreeMultimap.create(ImmutableMultimap.of(2, "two"));
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> SortedSetMultimap<K, V> wrap(final SortedSetMultimap<K, V> delegate) {

    Table<Integer, Integer, String> table1 = ImmutableTable.of(1, 1, "one");
    Table<Integer, Integer, String> table2 = ImmutableTable.of(2, 2, "two");
    new EqualsTester()
        .addEqualityGroup(table1, wrap(table1), wrap(table1))
        .addEqualityGroup(table2, wrap(table2))
        .testEquals();
  }

  private static <R, C, V> Table<R, C, V> wrap(final Table<R, C, V> delegate) {
    return new ForwardingTable<R, C, V>() {

  private static final File FILE = new File(".");

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(classInfo(ClassPathTest.class), classInfo(ClassPathTest.class))
        .addEqualityGroup(classInfo(Test.class), classInfo(Test.class, getClass().getClassLoader()))
        .addEqualityGroup(
            new ResourceInfo(FILE, "a/b/c.txt", getClass().getClassLoader()),

    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), Sets.newHashSet(v0(), v3()));
    expected.put(k1(), Sets.newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {
    resetContainer(

                    }));
  }

  public void testEqualsAndHashCode() {
    new EqualsTester()
        .addEqualityGroup(Optional.absent(), reserialize(Optional.absent()))
        .addEqualityGroup(Optional.of(Long.valueOf(5)), reserialize(Optional.of(Long.valueOf(5))))
        .addEqualityGroup(Optional.of(Long.valueOf(42)), reserialize(Optional.of(Long.valueOf(42))))
        .testEquals();
  }