*
     * The standard {@link Class#cast(Object)} method produces unsatisfactory error messages on some platforms
     * when it fails. All this method does is provide a better, consistent, error message.
     *
     * This should be used whenever there is a chance the cast could fail. If in doubt, use this.
     *
     * @param outputType The type to cast the input to

     */
    fun disableForCurrentThread() {
        ++inputTrackingDisabledCounterForThread
    }

    /**
     * Restores the input tracking state to the state it was in before the last call to
     * [disableForCurrentThread].
     */
    fun restoreForCurrentThread() {
        Preconditions.checkState(inputTrackingDisabledCounterForThread > 0, "Restore input tracking state without prior disable is detected")

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Contains declarations for instrumentation of plugins. Adds interceptors, bytecode upgrades etc."

dependencies {
    // All dependencies should be compileOnly, since this project is added also to worker classpath, so we don't pollute it.
    // If we need some dependency also at runtime we need to build a separate classpath and add it to :launcher project or :distributions-core project directly.

            [fromString(), "command.execute(['FOOBAR=foobar'] as String[], null)", "", "foobar"],
            [fromString(), "command.execute(['FOOBAR=foobar'] as List, null)", "", "foobar"],
            // null-safe call
            [fromGroovyString(), "command?.execute(null, null)", "", ""],
        ]
    }

import java.io.Closeable


internal
class ScopedFingerprintWriter<T>(
    private val writeContext: DefaultWriteContext
) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks
        // in case there was still an event being dispatched at closing time.
        synchronized(writeContext) {
            unsafeWrite(null)
            writeContext.close()
        }
    }

import org.gradle.test.fixtures.file.TestFile
import spock.lang.Shared

/**
 * Base class for tests that invoke external process with the dynamic Groovy code.
 * There are many different ways to run a process in Groovy, and all are producing different byte code.
 * The class supports compiling Groovy code in both indy and old-school CallSite modes.
 */

import static org.gradle.api.internal.initialization.DefaultScriptClassPathResolver.InstrumentationPhase.NOT_INSTRUMENTED;

/**
 * Registers all Artifact transforms required for the instrumentation pipelines.
 */
public class InstrumentationTransformRegisterer {

    private static final String BUILD_SERVICE_NAME = "__InternalCacheInstrumentationDataBuildService__";

        return configurations != null ? configurations : getConfigurationsWithDependencies();
    }

    /**
     * Returns the configurations to generate the report for. Defaults to all configurations of this task's containing
     * project.
     *
     * @return the configurations.
     */
    @Internal
    public Set<Configuration> getConfigurations() {
        return configurations;

/**
 * The environment state that was mutated at the configuration phase and has to be restored before running a build from the cache.
 *
 * The class can operate in two modes. First is the tracking mode when all environment-modifying operations are stored
 * and the list of the operations can be retrieved as the CachedEnvironmentState object. This mode is intended for the