* limitations under the License.
 */

package org.gradle.internal.serialize.codecs.dm.transform

import org.gradle.api.internal.DomainObjectContext
import org.gradle.api.internal.artifacts.transform.Transform
import org.gradle.api.internal.artifacts.transform.TransformInvocationFactory
import org.gradle.api.internal.artifacts.transform.TransformStep
import org.gradle.internal.cc.base.serialize.getProject

    def "as string"() {
        expect:
        asString().transform(1) == "1"
        asString().transform(null) == null
    }

    def "to URL"() {
        expect:
        toURL().transform(new URI("http://localhost:80/path")) == new URL("http://localhost:80/path")
    }

    def "by type"() {
        expect:
        type().transform("foo") == String
    }

    def "action as transformer"() {

 * limitations under the License.
 */

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

import org.gradle.api.artifacts.transform.InputArtifact;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformOutputs;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.file.ConfigurableFileCollection;

        when:
        def result = mapped.get()

        then:
        result == someOtherValue()

        and:
        1 * transform.transform(someValue()) >> someOtherValue()
        0 * transform._

        when:
        assert mapped.getOrNull() == someOtherValue()
        assert mapped.getOrElse(someValue()) == someOtherValue()

        then:

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

        }

        @Override
        public O transform(I input) {
            return Cast.cast(outputType, input);
        }
    }

    public static <T> Transformer<String, T> asString() {
        return new ToStringTransformer<T>();
    }

    private static class ToStringTransformer<T> implements Transformer<String, T> {
        @Override
        public String transform(T original) {

 * limitations under the License.
 */

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

import com.google.common.collect.Ordering;
import org.gradle.api.artifacts.transform.InputArtifact;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformOutputs;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.file.FileSystemLocation;

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