import java.io.File;

import static org.gradle.api.internal.initialization.transform.utils.InstrumentationTransformUtils.getInputType;

/**
 * Artifact transform that instruments external artifacts with Gradle instrumentation.
 */
@DisableCachingByDefault(because = "Instrumented jars are too big to cache")
public abstract class ExternalDependencyInstrumentingArtifactTransform extends BaseInstrumentingArtifactTransform {

    @Override

import org.gradle.work.DisableCachingByDefault;

import java.io.File;

/**
 * Artifact transform that instruments project based artifacts with Gradle instrumentation.
 */
@DisableCachingByDefault(because = "Instrumented jars are too big to cache.")
public abstract class ProjectDependencyInstrumentingArtifactTransform extends BaseInstrumentingArtifactTransform {

    @Override

// cmd/cover tool (during instrumentation) to be passed on to the
// compiler when the instrumented code is compiled. The cmd/cover tool
// creates a struct of this type, JSON-encodes it, and emits the
// result to a file, which the Go command then passes to the compiler
// when the instrumented package is built.
type CoverFixupConfig struct {
	// Name of the variable (created by cmd/cover) containing the

        then:
        gradleUserHomeOutputs("instrumented/instrumented-api-1.0.jar").size() == 2
        gradleUserHomeOutputs("instrumented/instrumented-impl-1.0.jar").size() == 2
    }

    @Requires(
        value = IntegTestPreconditions.NotConfigCached,
        reason = "Cc doesn't get invalidated when file dependency changes"
    )

            return;
        }

        if (isAgentSupported()) {
            // When agent is supported, we output an instrumented jar and an original jar,
            // so we can then later reconstruct instrumented jars classpath and original jars classpath.
            // We add `instrumented-` prefix to the file since names for the same transform needs to be unique when querying results via ArtifactCollection.

Harshavardhana <******@****.***> 1707959378 -0800

        then:
        def e = thrown(GradleException)
        e.message.contains("cannot be fully instrumented for Java ${JavaVersion.current().majorVersion}")
    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)
    def "fails loading if transformed multi-release jar does not instrument current JVM"() {
        given:
        def original = jar(testDir.file("original.jar")) {
            manifest {

        // The agent-based instrumentation doesn't load resources from the instrumented JAR, but from the original.
        // TODO(https://github.com/gradle/gradle/issues/18024) we really shouldn't instrument these "resource-looks-like-class" things.

        // We don't know the actual minimal supported version of the non-versioned class entries.

#         "fallback_tensor_conversion_host.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)
#         "kernel_fallback_op_handler.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)
#         "mnist.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)
#         "runtime_fallback_op_handler.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)

		{
			mode: "regonly",
			gran: "perblock",
		},
	}

	var incfg string
	apkgfiles := []string{filepath.Join(tpath, "a", "a.go")}
	for _, scenario := range scenarios {
		// Instrument package "a", producing a set of instrumented output
		// files and an 'output config' file to pass on to the compiler.
		ppath := "cfg/a"
		pname := "a"
		mode := scenario.mode
		gran := scenario.gran
		tag := mode + "_" + gran