}
        """

        when:
        succeeds("doIt", "--project-cache-dir", projectCacheDir.name)

        then:
        result.assertTasksExecuted(":buildSrc:classes", ":buildSrc:compileGroovy", ":buildSrc:compileJava", ":buildSrc:jar", ":buildSrc:processResources", ":doIt", ":included:doIt")
        projectCacheDir.assertExists()
        defaultProjectCacheDir.assertDoesNotExist()
    }

    @Override

    def context = Mock(BuildOperationContext)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def deleter = TestFiles.deleter()

    @Subject def projectCacheDir = new ProjectCacheDir(cacheDir, buildOperationRunner, deleter)

    def "cleans up unused version-specific cache directories"() {
        given:

    def worker = Mock(BuildOperationAwareWorker)
    def actionExecutionSpecFactory = Mock(ActionExecutionSpecFactory)
    def instantiator = Mock(Instantiator)
    def projectCacheDir = Mock(ProjectCacheDir)
    def classpathTransformer = Mock(CachedClasspathTransformer)
    ConditionalExecution task
    DefaultWorkerExecutor workerExecutor

    def setup() {

        then:
        configurationCache.assertStateLoaded()
    }

    def "configuration cache honours org.gradle.projectcachedir"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'help', '-Dorg.gradle.projectcachedir=custom-cache-dir'

        then:
        !file('.gradle/configuration-cache').exists()

        and:

                                            CachedClasspathTransformer classpathTransformer,
                                            ProjectLayout projectLayout,
                                            ProjectCacheDir projectCacheDir
                                            ) {

    private final DaemonForkOptions forkOptions;

    public ForkedWorkerRequirement(File workerDirectory, File projectCacheDir, DaemonForkOptions forkOptions) {
        super(workerDirectory, projectCacheDir, forkOptions.getClassLoaderStructure());
        this.forkOptions = forkOptions;
    }

    public DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

    def workingDir = new File("some-dir")
    def projectCacheDir = new File("some-cache-dir")
    def options = Stub(DaemonForkOptions)
    def requirement = new ForkedWorkerRequirement(workingDir, projectCacheDir, options)
    def spec = Stub(IsolatedParametersActionExecutionSpec)

    def setup() {

import org.gradle.api.internal.ClassPathRegistry
import org.gradle.api.internal.tasks.compile.processing.AnnotationProcessorDetector
import org.gradle.api.problems.internal.InternalProblems
import org.gradle.initialization.layout.ProjectCacheDir
import org.gradle.process.internal.ExecHandleFactory
import org.gradle.process.internal.JavaForkOptionsFactory
import org.gradle.workers.internal.ActionExecutionSpecFactory

        String implementationClassName = decoder.readString();
        boolean usesInternalServices = decoder.readBoolean();
        String baseDirPath = decoder.readString();
        String projectCacheDir = decoder.readString();
        byte[] serializedParameters = decoder.readBinary();
        byte classLoaderStructureTag = decoder.readByte();
        ClassLoaderStructure classLoaderStructure;

    }

    /**
     * Sets the project's cache location. Set to null to use the default location.
     */
    public void setProjectCacheDir(@Nullable File projectCacheDir) {
        this.projectCacheDir = projectCacheDir;
    }

    /**
     * Returns the project's cache dir.
     *
     * <p>Note that this directory is managed by Gradle, and it assumes full ownership of its contents.