final Multiset<? extends E> delegate;

    UnmodifiableMultiset(Multiset<? extends E> delegate) {
      this.delegate = delegate;
    }

    @SuppressWarnings("unchecked")
    @Override
    protected Multiset<E> delegate() {
      // This is safe because all non-covariant methods are overridden
      return (Multiset<E>) delegate;
    }

    @LazyInit transient @Nullable Set<E> elementSet;

 */
@Named("apply")
@Singleton
public class Apply extends AbstractUpgradeGoal {

    @Inject
    public Apply(StrategyOrchestrator orchestrator) {
        super(orchestrator);
    }

    @Override
    protected boolean shouldSaveModifications() {
        return true;
    }

    @Override
    public int execute(UpgradeContext context) throws Exception {
        context.info("Maven Upgrade Tool - Apply");

 */
@Named("check")
@Singleton
public class Check extends AbstractUpgradeGoal {

    @Inject
    public Check(StrategyOrchestrator orchestrator) {
        super(orchestrator);
    }

    @Override
    protected boolean shouldSaveModifications() {
        return false;
    }

    @Override
    public int execute(UpgradeContext context) throws Exception {
        context.info("Maven Upgrade Tool - Check");

 */
@J2ktIncompatible
@GwtIncompatible
abstract class WrappingScheduledExecutorService extends WrappingExecutorService
    implements ScheduledExecutorService {
  final ScheduledExecutorService delegate;

  protected WrappingScheduledExecutorService(ScheduledExecutorService delegate) {
    super(delegate);
    this.delegate = delegate;
  }

  @Override

    Integer[] array = new Integer[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Integer) e;
    }
    return create(array);
  }

  protected abstract Set<Integer> create(Integer[] elements);

  @Override
  public Integer[] createArray(int length) {
    return new Integer[length];
  }

  /**
   * {@inheritDoc}
   *

    AnEnum[] array = new AnEnum[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (AnEnum) e;
    }
    return create(array);
  }

  protected abstract Multiset<AnEnum> create(AnEnum[] elements);

  @Override
  public AnEnum[] createArray(int length) {
    return new AnEnum[length];
  }

  /** Sorts the enums according to their natural ordering. */
  /*

        return baseVersion;
    }

    protected String getBaseVersionInternal() {
        if ((baseVersion == null) && (version != null)) {
            setBaseVersionInternal(version);
        }

        return baseVersion;
    }

    @Override
    public void setBaseVersion(String baseVersion) {
        setBaseVersionInternal(baseVersion);
    }

    protected void setBaseVersionInternal(String baseVersion) {

                return formattedProgressedSize + "/" + formattedSize;
            } else {
                return format(progressedSize);
            }
        }
    }

    protected PrintStream out;

    protected AbstractMavenTransferListener(PrintStream out) {
        this.out = out;
    }

    @Override
    public void transferInitiated(TransferEvent event) {

  public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTest(
        MapTestSuiteBuilder.using(
                new TestStringMapGenerator() {
                  @Override
                  protected Map<String, String> create(Entry<String, String>[] entries) {
                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {

  /*
   * Previously we had a field named set that was initialized to the value of
   * collection in setUp(), but that caused problems when a tester changed the
   * value of set or collection but not both.
   */
  protected final Set<E> getSet() {
    return (Set<E>) collection;
  }