def artifactType = Attribute.of('artifactType', String)
                def instrumented = Attribute.of('${INSTRUMENTED_ATTRIBUTE.name}', String.class)
                dependencies {
                    classpath "com.test:lib:1.0"
                    registerTransform(MakeColor) {
                        from.attribute(artifactType, 'jar').attribute(instrumented, '${NOT_INSTRUMENTED.value}')

plugins {
    `java-library`
    `maven-publish`
    `instrumented-jars`
}

publishing {
    repositories {
        maven {
            setUrl("${buildDir}/repo")
        }
    }
    publications {
        create<MavenPublication>("myPublication") {
            from(components["myAdhocComponent"])
        }
    }
}

if (project.hasProperty("disableGradleMetadata")) {
    // tag::disable_gradle_metadata_publication[]

 */

package org.gradle.internal.classpath.types

import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class ExternalPluginsInstrumentationTypeRegistryTest extends ConcurrentSpec {

    def "should collect instrumented types"() {
        given:
        def gradleCoreRegistry = new TestGradleCoreInstrumentationTypeRegistry([
            "org/gradle/api/DefaultTask": ["org/gradle/api/Task", "org/gradle/api/internal/TaskInternal"] as Set,

            (CodeGeneratorContributor) PropertyUpgradeClassSourceGenerator::new,
            // Generate resource with instrumented properties
            (ResourceGeneratorContributor) InstrumentedPropertiesResourceGenerator::new,

            // Generate resource with instrumented types
            (ResourceGeneratorContributor) InstrumentedTypesResourceGenerator::new
        );
    }

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

class SystemPropertyInstrumentationInStaticGroovyIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "#method is instrumented in static Groovy"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        // Why the separate plugin? The Project.getProperties() is available in the build.gradle as getProperties().

import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Assert.*

/**
 * Instrumented test, which will execute on an Android device.
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
    @Test

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

class SystemPropertyInstrumentationInDynamicGroovyIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "#method is instrumented in dynamic Groovy #indyStatus"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${Plugin.name}

import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Assert.*

/**
 * Instrumented test, which will execute on an Android device.
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
    @Test

    extendsFrom(configurations["implementation"], configurations["runtimeOnly"])
}
// end::declare-outgoing-configuration[]

val instrumentedJar = tasks.register("instrumentedJar", Jar::class) {
    archiveClassifier = "instrumented"
}

// tag::attach-outgoing-artifact[]
artifacts {
    add("instrumentedJars", instrumentedJar)
}
// end::attach-outgoing-artifact[]

/*
// tag::attach-outgoing-artifact-explicit[]
artifacts {

//go:build (darwin || linux || windows || freebsd) && (amd64 || arm64)

package fuzz

import (
	"unsafe"
)

// coverage returns a []byte containing unique 8-bit counters for each edge of
// the instrumented source code. This coverage data will only be generated if
// `-d=libfuzzer` is set at build time. This can be used to understand the code
// coverage of a test execution.
func coverage() []byte {