implements TestSetGenerator<E> {

  ReserializingTestSetGenerator(TestSetGenerator<E> delegate) {
    super(delegate);
  }

  public static <E> TestSetGenerator<E> newInstance(TestSetGenerator<E> delegate) {
    return new ReserializingTestSetGenerator<>(delegate);
  }

  @Override
  public Set<E> create(Object... elements) {
    return (Set<E>) super.create(elements);
  }

      return Iterators.transform(entries, UnmodifiableEntry::new);
    }

    private UnmodifiableEntry(Entry<K, V> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    protected Entry<K, V> delegate() {
      return delegate;
    }

    @Override
    @ParametricNullness
    public V setValue(@ParametricNullness V value) {

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> ListMultimap<K, V> wrap(final ListMultimap<K, V> delegate) {
    return new ForwardingListMultimap<K, V>() {
      @Override
      protected ListMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> ListMultimap<K, V> wrap(final ListMultimap<K, V> delegate) {
    return new ForwardingListMultimap<K, V>() {
      @Override
      protected ListMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> SetMultimap<K, V> wrap(final SetMultimap<K, V> delegate) {
    return new ForwardingSetMultimap<K, V>() {
      @Override
      protected SetMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

        .testEquals();
  }

  private static <K, V> SortedSetMultimap<K, V> wrap(final SortedSetMultimap<K, V> delegate) {
    return new ForwardingSortedSetMultimap<K, V>() {
      @Override
      protected SortedSetMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> Set<T> wrap(final Set<T> delegate) {
    return new ForwardingSet<T>() {
      @Override
      protected Set<T> delegate() {
        return delegate;
      }
    };
  }

    private final Callable<T> delegate;

    public WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    public WrappedRunnable(Runnable delegate) {

  @Override
  protected abstract SortedMap<K, V> delegate();

  @Override
  @CheckForNull
  public Comparator<? super K> comparator() {
    return delegate().comparator();
  }

  @Override
  @ParametricNullness
  public K firstKey() {
    return delegate().firstKey();
  }

  @Override
  public SortedMap<K, V> headMap(@ParametricNullness K toKey) {
    return delegate().headMap(toKey);
  }

  @Override

    return tailMap(fromKey);
  }

  private ImmutableSortedMap<K, V> newView(SortedMap<K, V> delegate) {
    return newView(delegate, comparator);
  }

  private static <K, V> ImmutableSortedMap<K, V> newView(
      SortedMap<K, V> delegate, Comparator<? super K> comparator) {
    return new ImmutableSortedMap<K, V>(delegate, comparator);
  }

  /*