*/

package org.gradle.internal.cc.impl.serialize

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.internal.classpath.TransformedClassPath
import org.gradle.internal.serialize.Decoder
import org.gradle.internal.serialize.Encoder
import org.gradle.internal.serialize.graph.readFile
import org.gradle.internal.serialize.graph.writeCollection

            file("Foo.class").bytes = INSTRUMENTED_CLASS
        }
        TransformedClassPath cp = classPath((original): transformed)

        expect:
        INSTRUMENTED_CLASS == loadTransformedClass(cp, "Foo", original)
    }

    private static final byte[] loadTransformedClass(TransformedClassPath cp, String className, File original) {
        try (TransformReplacer replacer = new TransformReplacer(cp)) {

import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.AGENT_INSTRUMENTATION_MARKER;
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.LEGACY_INSTRUMENTATION_MARKER;
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.ORIGINAL_FILE_DOES_NOT_EXIST_MARKER;
import static org.gradle.internal.classpath.TransformedClassPath.INSTRUMENTED_DIR_NAME;

        }
    }

    public static VisitableURLClassLoader fromClassPath(String name, ClassLoader parent, ClassPath classPath) {
        if (classPath instanceof TransformedClassPath) {
            return new InstrumentingVisitableURLClassLoader(name, parent, (TransformedClassPath) classPath);
        }
        return new VisitableURLClassLoader(name, parent, classPath);
    }

            ClassPath transformedClassPath = transformedPipeline.transform(classPath);
            List<File> copiedOriginalJars = copiedClassPath.getAsFiles();
            List<File> transformedJars = transformedClassPath.getAsFiles();
            int size = copiedOriginalJars.size();
            assert size == transformedJars.size();

            return targetScope.createLockedChild(scopeName, origin, scriptClassPath, sourceHashCode, parent -> {
                if (scriptClassPath instanceof TransformedClassPath) {
                    return new InstrumentingScriptClassLoader(source, parent, (TransformedClassPath) scriptClassPath, sourceHashCode);
                }
                return new ScriptClassLoader(source, parent, scriptClassPath, sourceHashCode);
            });

 * <p>
 * This class is thread-safe.
 */
public class TransformReplacer implements Closeable {
    private static final Loader SKIP_INSTRUMENTATION = new Loader();
    private final ConcurrentMap<ProtectionDomain, Loader> loaders;
    private final TransformedClassPath classPath;
    private volatile boolean closed;

import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.api.invocation.Gradle;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.classpath.TransformedClassPath;
import org.gradle.internal.component.local.model.OpaqueComponentIdentifier;
import org.gradle.internal.instrumentation.agent.AgentStatus;
import org.gradle.internal.lazy.Lazy;

import static org.gradle.api.internal.initialization.transform.utils.InstrumentationTransformUtils.MERGE_OUTPUT_DIR
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.INSTRUMENTATION_CLASSPATH_MARKER

/**
 * A mutator that cleans up the artifact transform cache directory, but leaves folders with the instrumented jars.
 *

import static org.gradle.api.internal.initialization.transform.utils.InstrumentationTransformUtils.MERGE_OUTPUT_DIR
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.INSTRUMENTATION_CLASSPATH_MARKER
import static org.gradle.performance.mutator.ClearArtifactTransformCacheWithoutInstrumentedJarsMutator.GRADLE_PRE_8_8_CLASSPATH_MAKER