for (ArtifactTransformation transform : artifactTransformations) {
            transform.transformForResolve(artifact, remoteRepositories, localRepository);
        }
    }

    public void transformForInstall(Artifact artifact, ArtifactRepository localRepository)
            throws ArtifactInstallationException {
        for (ArtifactTransformation transform : artifactTransformations) {

    void testCompileClasspathTransform() throws Exception {
        ClasspathContainer res;

        res = transform.transform(graph, ArtifactScopeEnum.compile, false);

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

 * under the License.
 */
package org.apache.maven.artifact.transform;

import javax.inject.Inject;

import java.util.List;

import org.apache.maven.repository.legacy.resolver.transform.ArtifactTransformation;
import org.apache.maven.repository.legacy.resolver.transform.ArtifactTransformationManager;
import org.apache.maven.repository.legacy.resolver.transform.LatestArtifactTransformation;

                .build());
        Model actual = transform(initial);
        assertTrue(equalsDeep(expected, actual));
    }

    Model transform(Model model) {
        Model transformed = model.clone();
        new BuildModelSourceTransformer().transform(pomFile, context, transformed);
        return transformed;
    }

    public static boolean equalsDeep(Object m1, Object m2) {

    List<String> transform = transform(listIteratorOnlyList, SOME_FUNCTION);
    assertTrue(elementsEqual(transform, transform(randomAccessList, SOME_FUNCTION)));
  }

  private static class ListIterationOnlyList<E> extends ForwardingList<E> {
    private final List<E> realDelegate;

    private ListIterationOnlyList(List<E> realDelegate) {
      this.realDelegate = realDelegate;
    }

    @Override

    List<String> transform = transform(listIteratorOnlyList, SOME_FUNCTION);
    assertTrue(elementsEqual(transform, transform(randomAccessList, SOME_FUNCTION)));
  }

  private static class ListIterationOnlyList<E> extends ForwardingList<E> {
    private final List<E> realDelegate;

    private ListIterationOnlyList(List<E> realDelegate) {
      this.realDelegate = realDelegate;
    }

    @Override

        }
    }

    static class ExtensionInterpolator extends MavenTransformer {
        ExtensionInterpolator(Function<String, String> transformer) {
            super(transformer);
        }

        public XmlNode transform(XmlNode node) {
            return super.transform(node);
        }
    }

 */
package org.apache.maven.model.building;

import java.nio.file.Path;

import org.apache.maven.model.Model;

/**
 * The ModelSourceTransformer is a way to transform the local pom while streaming the input.
 *
 * The {@link #transform(Path, TransformerContext, Model)} method uses a Path on purpose, to ensure the
 * local pom is the original source.
 *
 * @since 4.0.0

  }

  public void testTransform_absent() {
    assertEquals(Optional.absent(), Optional.absent().transform(Functions.identity()));
    assertEquals(Optional.absent(), Optional.absent().transform(Functions.toStringFunction()));
  }

  public void testTransform_presentIdentity() {
    assertEquals(Optional.of("a"), Optional.of("a").transform(Functions.identity()));
  }

  public void testTransform_presentToString() {

        Model model = result.getRawModel();
        return transform(model, project);
    }

    protected Model buildNonPom(RepositorySystemSession session, MavenProject project, Path src)
            throws ModelBuilderException {
        ModelBuilderResult result = buildModel(session, project, src);
        Model model = result.getEffectiveModel();
        return transform(model, project);
    }