*/
        INSTRUMENTATION_CLASSPATH_MARKER(".gradle-instrumented-classpath.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that it is using agent instrumentation.
         */
        AGENT_INSTRUMENTATION_MARKER(".gradle-agent-instrumented.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that it is using legacy instrumentation.
         */

    /**
     * Registers the current call in the instrumented calls stack.
     * @return an entry point call site token that must later be passed to {@link InstrumentedGroovyCallsTracker#leaveCall}
     */
    EntryPointCallSite enterCall(String callerClassName, String callableName, CallKind callKind);

    /**

        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(self, consumer);
        return FilesKt.readBytes(self);
    }

    @InterceptCalls
    @StaticMethod(ofClass = FilesKt.class)
    public static void intercept_forEachBlock(
        File self,
        Function2<?, ?, ?> action,
        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(self, consumer);

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

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

package org.gradle.instrumentation.agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;

/**
 * An entry point for the on-the-fly bytecode instrumentation agent.
 */
public class Agent {
    private static volatile Instrumentation instrumentation;

        val superTypes = mergeSuperTypes()
        // Keep only instrumented super types as we don't need to others for instrumentation
        val onlyInstrumentedSuperTypes = keepOnlyInstrumentedSuperTypes(superTypes, instrumentedClasses)
        writeSuperTypes(onlyInstrumentedSuperTypes)
    }

    /**
     * Finds all instrumented classes from `instrumented-classes.txt` file.

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

        createProject()
    }

    @Test
    fun `should output instrumented-super-types properties with instrumented org-gradle super types with stable order`() {
        // When
        assertSucceeds()

        // Then
        val instrumentedSuperTypes = File(projectRoot, "distribution/build/instrumentation/instrumented-super-types.properties").readLines()
        val expectedSuperTypes = listOf(

        File file,
        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(file, consumer);
    }

    @InterceptCalls
    @AfterConstructor
    public static void interceptFileInputStreamConstructor(
        @Receiver FileInputStream receiver,
        String path,
        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(path, consumer);
    }

        Charset charset,
        @KotlinDefaultMask int mask,
        @CallerClassName String consumer
    ) throws Throwable {
        return mask != 0 ?
            Instrumented.kotlinIoFilesKtReadTextDefault(thisFile, charset, mask, null, consumer) :
            Instrumented.kotlinIoFilesKtReadText(thisFile, charset, consumer);
    }