package p

// simplified test case

type transform[T any] struct{}
type pair[S any] struct {}

var _ transform[step]

type box transform[step]
type step = pair[box]

// test case from issue

type Transform[T any] struct{ hold T }
type Pair[S, T any] struct {
	First  S
	Second T
}

var first Transform[Step]

        when:
        run("transform")

        then:
        result.assertTasksSkipped(":transform")

        when:
        file("dir1/file3.txt").text = "new"
        run("transform")

        then:
        result.assertTasksNotSkipped(":transform")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

            // Make sure the transform executes each time
            timestamp = System.nanoTime()
// tag::artifact-transform-registration[]
        }
// tag::artifact-transform-attribute-setup[]
    }
}
// end::artifact-transform-attribute-setup[]
// end::artifact-transform-registration[]

repositories {
    mavenCentral()
}

// tag::artifact-transform-attribute-setup[]

import org.gradle.tooling.events.OperationType
import org.gradle.tooling.events.ProgressListener
import org.gradle.tooling.events.transform.TransformFailureResult
import org.gradle.tooling.events.transform.TransformFinishEvent
import org.gradle.tooling.events.transform.TransformStartEvent
import org.gradle.tooling.events.transform.TransformSuccessResult
import org.gradle.tooling.internal.protocol.InternalBuildProgressListener

import java.io.File;

/**
 * A single transform step in a transform chain.
 * <p>
 * Transforms a subject by invoking a transform on each of the subjects files.
 *
 * @see TransformChain
 */
public class TransformStep implements TaskDependencyContainer, Describable {
    private static final Logger LOGGER = LoggerFactory.getLogger(TransformStep.class);

    private final Transform transform;

        then:
        output.count("transform") == 3
        outputContains("transform external test-1.2.jar")
        outputContains("transform local test2-1.5.thing using [test-1.2.jar.external]")
        outputContains("transform local test3-1.5.thing using [test-1.2.jar.external]")
        outputContains("artifacts = [test2-1.5.thing.local (test:test2:1.5), test3-1.5.thing.local (test:test3:1.5)]")

        when:

import org.gradle.api.internal.initialization.transform.InstrumentationAnalysisTransform;
import org.gradle.api.internal.initialization.transform.MergeInstrumentationAnalysisTransform;
import org.gradle.api.internal.initialization.transform.ProjectDependencyInstrumentingArtifactTransform;
import org.gradle.api.internal.initialization.transform.services.CacheInstrumentationDataBuildService;

 * limitations under the License.
 */

package org.gradle.integtests.resolve.transform

import com.google.common.collect.ImmutableList
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.attributes.Attribute

 */

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

import org.gradle.api.Describable;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.Build.class)
public interface TransformExecutionListener {

    /**
     * This method is called immediately before a transform is executed.
     */

    def "does nothing to empty classpath when transform is none"() {
        given:
        def classpath = DefaultClassPath.of()

        when:
        def cachedClasspath = transformer.transform(classpath, None)

        then:
        cachedClasspath.empty

        and:
        0 * fileAccessTimeJournal._
    }

    def "does nothing to empty classpath when transform is build logic"() {
        given: