static <E> Set<E> reserializeAndAssertLenient(Set<E> original) {
    Set<E> copy = reserialize(original);
    assertEquals(original, copy);
    assertTrue(copy instanceof ImmutableSet);
    return copy;
  }

  @CanIgnoreReturnValue
  @GwtIncompatible // SerializableTester
  static <E> Multiset<E> reserializeAndAssertLenient(Multiset<E> original) {
    Multiset<E> copy = reserialize(original);
    assertEquals(original, copy);

  static <E> Set<E> reserializeAndAssertLenient(Set<E> original) {
    Set<E> copy = reserialize(original);
    assertEquals(original, copy);
    assertTrue(copy instanceof ImmutableSet);
    return copy;
  }

  @CanIgnoreReturnValue
  @GwtIncompatible // SerializableTester
  static <E> Multiset<E> reserializeAndAssertLenient(Multiset<E> original) {
    Multiset<E> copy = reserialize(original);
    assertEquals(original, copy);

    String ROLE = ArtifactTransformationManager.class.getName();

    /**
     * Take in an artifact and return the transformed artifact for locating in the remote repository. If no
     * transformation has occurred the original artifact is returned.
     *
     * @param artifact           Artifact to be transformed.
     * @param request the repositories to check
     */
    void transformForResolve(Artifact artifact, RepositoryRequest request)

        ? ((TransposeTable<R, C, V>) table).original
        : new TransposeTable<C, R, V>(table);
  }

  private static class TransposeTable<
          C extends @Nullable Object, R extends @Nullable Object, V extends @Nullable Object>
      extends AbstractTable<C, R, V> {
    final Table<R, C, V> original;

    TransposeTable(Table<R, C, V> original) {
      this.original = checkNotNull(original);
    }

  private static <R, C, V> void validateTableCopies(Table<R, C, V> original) {
    Table<R, C, V> copy = ImmutableTable.copyOf(original);
    assertEquals(original, copy);
    validateViewOrdering(original, copy);

    Table<R, C, V> built = ImmutableTable.<R, C, V>builder().putAll(original).build();
    assertEquals(original, built);
    validateViewOrdering(original, built);
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testEqualsMultimapWithNullKey() {
    Multimap<K, V> original = multimap();
    initMultimapWithNullKey();
    Multimap<K, V> withNull = multimap();
    new EqualsTester()
        .addEqualityGroup(original)
        .addEqualityGroup(
            withNull, getSubjectGenerator().create((Object[]) createArrayWithNullKey()))
        .testEquals();
  }

    }

    @Override
    public Set<K> keySet() {
        // return original keys
        return parent.keySet();
    }

    @Override
    public Collection<V> values() {
        return parent.values();
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        // return original keys
        return parent.entrySet();
    }

    @Override

        this.importedFrom = null;
    }

    public InputLocation(InputLocation original) {
        this.lineNumber = original.lineNumber;
        this.columnNumber = original.columnNumber;
        this.source = original.source;
        this.locations = original.locations;
        this.importedFrom = original.importedFrom;
    }

    public int getLineNumber() {
        return lineNumber;
    }

            }
        }

        return to;
    }

    private static <T> List<T> copyList(List<T> original) {
        List<T> copy = null;

        if (original != null) {
            copy = new ArrayList<>();

            if (!original.isEmpty()) {
                copy.addAll(original);
            }
        }

        return copy;
    }

                // The first definition wins.
                Lifecycle original = phaseToLifecycleMap.put(phase, lifecycle);
                if (original != null && logger.isWarnEnabled()) {
                    logger.warn(
                            "Duplicated lifecycle phase {}. Defined in {} but also in {}",
                            phase,
                            original.getId(),
                            lifecycle.getId());