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

              @Override
              public Deque<?> apply(Deque delegate) {
                return wrap((Deque<?>) delegate);
              }
            });
  }

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

    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);
  }

    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
  Set<E> createElementSet() {
    Set<E> delegate = countMap.keySet();
    return new ForwardingSet<E>() {
      @Override
      protected Set<E> delegate() {
        return delegate;
      }

      @Override
      public boolean contains(@CheckForNull Object object) {
        return object != null && Collections2.safeContains(delegate, object);
      }

      @Override

        .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;
      }
    };
  }

  @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

        .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;
      }
    };
  }