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)

    def "should cleanup all transforms-X folders except the ones with instrumented jars"() {
        given:
        def cachesDir = new File(gradleUserHome, "caches")
        createFile(new File(cachesDir, "transforms-1/first/transformed/file"))
        createFile(new File(cachesDir, "transforms-1/first/metadata.bin"))
        createFile(new File(cachesDir, "transforms-1/first/transformed/instrumented/file"))

        }
        return result
    }

    String instrument(String idExpr) {
        return """println("script=" + $idExpr + "=" + getClass().name + "," + getClass().classLoader.getURLs().collect { new File(it.toURI()) })"""
    }

    String simpleBuild(String content = '') {
        """
            ${content}
            ${instrument("project.path")}
        """
    }

 * 3. A properties file with instrumented class dependencies in a file.<br><br>
 *
 * File with instrumented class dependencies is a properties file like:<br>
 * [class name 1]=[instrumented super type 1],[instrumented super type 2],...<br>
 * [class name 2]=[instrumented super type 1],[instrumented super type 2],...<br>
 * ...
 */
@DisableCachingByDefault(because = "Not worth caching.")

            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements, 'instrumented-jar'))
        }
    }
}
// end::declare-outgoing-configuration[]

def instrumentedJar = tasks.register("instrumentedJar", Jar) {
    archiveClassifier = "instrumented"
}

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

        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named("instrumented-jar"))
    }
}
// end::declare-outgoing-configuration[]

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

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

// CovMetaBlob is a container for holding the meta-data symbol (an
// RODATA variable) for an instrumented Go package. Here "p" points to
// the symbol itself, "len" is the length of the sym in bytes, and
// "hash" is an md5sum for the sym computed by the compiler. When
// the init function for a coverage-instrumented package executes, it
// will make a call into the runtime which will create a covMetaBlob

import java.io.UncheckedIOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.stream.Collectors;

/**
 * Writes all instrumented types with inherited method interception to a resources
 */
public class InstrumentedTypesResourceGenerator implements InstrumentationResourceGenerator {
    @Override

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

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

/**
 * Test cases for single-argument {@code ProcessGroovyMethods.execute}:
 * <pre>
 *     ProcessGroovyMethod.execute("echo 123")
 *     ProcessGroovyMethod.execute(["echo", "123"])
 * </pre>
 */

        }
        // end::create_adhoc_component[]
    }

    private fun Project.attachArtifact() {
        val instrumentedJar = tasks.register<Jar>("instrumentedJar") {
            archiveClassifier.set("instrumented")
        }

        artifacts {
            add("instrumentedJars", instrumentedJar)
        }

    }

    private fun Project.createOutgoingConfiguration(): Configuration {