if n.Class == ir.PFUNC {
		return false
	}
	if n.Sym().Pkg != types.LocalPkg {
		return false
	}
	// Do not instrument any _cgo_ related global variables, because they are declared in C code.
	if strings.Contains(n.Sym().Name, "cgo") {
		return false
	}

	// Do not instrument globals that are linknamed, because their home package will do the work.
	if n.Sym().Linkname != "" {
		return false
	}

// MetricDefinition records a metric's metadata.
// This is used to work around two limitations of OpenTelemetry:
//   - (https://github.com/open-telemetry/opentelemetry-go/issues/4003) Histogram buckets cannot be defined per instrument.
//     instead, we record all metric definitions and add them as Views at registration time.

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

package org.gradle.internal.cc.impl.inputs.process.instrument

class ProcessInstrumentationInKotlinIntegrationTest extends AbstractProcessInstrumentationIntegrationTest {
    def "#title is intercepted in kotlin build script"(VarInitializer varInitializer) {
        given:

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

package org.gradle.internal.cc.impl.inputs.process.instrument

class ProcessInstrumentationInJavaIntegrationTest extends AbstractProcessInstrumentationIntegrationTest {
    def "#title is intercepted in java build code"(VarInitializer varInitializer) {
        given:

     * @param cause the original exception
     */
    public void classLoadingError(@Nullable String className, Throwable cause) {
        ClassNotFoundException newError = new ClassNotFoundException(
            "Failed to instrument class " + className + " in " + classLoaderName, cause);
        Throwable prevError = lastError.get();
        if (prevError == null) {
            lastError.set(newError);
        } else {

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

        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 {

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

package org.gradle.internal.cc.impl.inputs.process.instrument

import org.gradle.internal.cc.impl.AbstractConfigurationCacheIntegrationTest
import org.gradle.process.ShellScript

/**
 * Base class for all external process invocation instrumentation tests.
 */

        file('src/main/java/org/gradle/MySystemClassLoader.java') << customSystemClassLoaderClass
        file('src/main/java/org/gradle/MyAgent.java') << """
            package org.gradle;

            import java.lang.instrument.Instrumentation;

            public class MyAgent {
                public static void premain(String args, Instrumentation instrumentation) {
                    System.setProperty("using.custom.agent", "true");

        def builder = artifactBuilder()
        builder.sourceFile("TestAgent.java") << """
            public class TestAgent {
                public static void premain(String p1, java.lang.instrument.Instrumentation p2) {
                }
            }
        """
        builder.manifestAttributes("Premain-Class": "TestAgent")
        def agentJar = file("agent.jar")
        builder.buildJar(agentJar)