when(sessionDataMock.get(any())).thenReturn(new NoTransformerContext());

        Path beforePomFile =
                Paths.get("src/test/resources/projects/transform/before.pom").toAbsolutePath();
        Path afterPomFile =
                Paths.get("src/test/resources/projects/transform/after.pom").toAbsolutePath();
        Path tempFile = Files.createTempFile("", ".pom");
        Files.delete(tempFile);

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.InputSource;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;

import java.util.zip.ZipFile

import org.gradle.api.artifacts.transform.TransformParameters

// tag::artifact-transform-unzip[]
abstract class Unzip implements TransformAction<TransformParameters.None> { // <1>
    @InputArtifact                                                          // <2>
    abstract Provider<FileSystemLocation> getInputArtifact()

    @Override
    void transform(TransformOutputs outputs) {

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

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

            String basicName = subjectName + " with " + transformStepName;
            return BuildOperationDescriptor.displayName("Transform " + basicName)
                .progressDisplayName(TRANSFORMING_PROGRESS_PREFIX + basicName)
                .metadata(BuildOperationCategory.TRANSFORM)
                .details(new ExecutePlannedTransformStepBuildOperationDetails(TransformStepNode.this, transformStepName, subjectName));
        }

 */

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.Action;
import org.gradle.api.NonExtensible;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.artifacts.transform.TransformSpec;
import org.gradle.api.artifacts.transform.VariantTransformConfigurationException;

package org.gradle.kotlin.dsl.fixtures


fun <T> Iterable<T>.joinLines(transform: (T) -> String) =

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.resolve.transform

import groovy.transform.SelfType
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleExecuter

     * Updates jar/directory content hash to account for the transform produced by this factory.
     *
     * @param hasher the hasher to modify
     */
    void applyConfigurationTo(Hasher hasher);

    /**
     * Returns the transformation to be applied to the given jar/directory.
     *
     * @param file the jar/directory to transform
     * @param classTransform the transform that will be applied to every class

 * limitations under the License.
 */

package org.gradle.api.artifacts.transform;

import org.gradle.api.Action;

import javax.inject.Inject;

/**
 * Interface for artifact transform actions.
 *
 * <p>
 *     A transform action implementation is an abstract class implementing the {@link #transform(TransformOutputs)} method.
 *     A minimal implementation may look like this:
 * </p>
 *