import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.work.DisableCachingByDefault


@DisableCachingByDefault(because = "Abstract super-class, not to be instantiated directly")
abstract class ClassPathSensitiveTask : DefaultTask(), ClassPathAware {

    @get:Internal
    protected
    val classPath: ClassPath

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath

import org.gradle.jvm.JvmLibrary

import org.gradle.kotlin.dsl.embeddedKotlinVersion
import org.gradle.kotlin.dsl.get

import org.gradle.language.base.artifact.SourcesArtifact


internal
fun sourcePathFor(scriptHandlers: List<ScriptHandler>): ClassPath {
    var sourcePath = ClassPath.EMPTY

The whole transformation process normally happens on the first use of a build or when a plugin jar is added to the build script classpath.
We transform the jar and cache transformed jars for future use.

We transform plugins classpath, TestKit classpath and buildscript classes separately. 

        then:
        output.contains """
classpath
\\--- org:toplevel2:1.0
     +--- org:leaf3:1.0
     \\--- org:leaf4:1.0
"""
        when:
        run(":client:buildEnvironment")

        then:
        output.contains """
classpath
No dependencies
"""

        when:
        run(":buildEnvironment")

        then:
        output.contains """
classpath
\\--- org:toplevel1:1.0

    /**
     * Returns the classpath used to compile this source.
     *
     * @return The classpath. Never returns null.
     */
    FileCollection getCompileClasspath();

    /**
     * Sets the classpath used to compile this source.
     *
     * @param classpath The classpath. Should not be null.
     */
    void setCompileClasspath(FileCollection classpath);

    /**

            assert spec.name == "test"
            assert spec.classpath == classPath
        }
        1 * visitor.visitClassPath(classPath)
        1 * visitor.visitParent(parent)
        0 * visitor._
    }

        this.fingerprinter = fingerprinter;
        this.fileCollectionFactory = fileCollectionFactory;
    }

    @Override
    public HashCode hash(ClassPath classpath) {
        CurrentFileCollectionFingerprint fingerprint = fingerprinter.fingerprint(fileCollectionFactory.fixed(classpath.getAsFiles()));
        return fingerprint.getHash();
    }

package org.gradle.api.internal.project.antbuilder;

import org.gradle.internal.classpath.ClassPath;

import java.lang.ref.SoftReference;

class CacheEntry extends SoftReference<CachedClassLoader> {

    private final ClassPath key;

    CacheEntry(ClassPath key, CachedClassLoader cached) {
        super(cached);
        this.key = key;
    }

    public ClassPath getKey() {
        return key;
    }

        return inferClasspath(inferModulePath, fileCollectionFactory.fixed(classpath));
    }

    public FileCollection inferClasspath(boolean inferModulePath, FileCollection classpath) {
        if (classpath == null) {
            return FileCollectionFactory.empty();
        }
        if (!inferModulePath) {
            return classpath;
        }

                id 'java-library'
            }
        """
    }

    @ToBeFixedForConfigurationCache
    def "dependencies in main source set dependency configurations are not marked with test classpath attribute"() {
        given:
        file('a/build.gradle') << """
            dependencies {
                implementation project(':b')
            }
        """

        when:
        run 'eclipse'