private final ClassLoaderStructure classLoaderStructure;

    public IsolatedClassLoaderWorkerRequirement(File workerDirectory, File projectCacheDir, ClassLoaderStructure classLoaderStructure) {
        super(workerDirectory, projectCacheDir);
        this.classLoaderStructure = classLoaderStructure;
    }

    public ClassLoaderStructure getClassLoaderStructure() {
        return classLoaderStructure;

        decodedSpec.classLoaderStructure == spec.classLoaderStructure
        decodedSpec.baseDir.canonicalPath == spec.baseDir.canonicalPath
        decodedSpec.projectCacheDir.canonicalPath == spec.projectCacheDir.canonicalPath
        decodedSpec.internalServicesRequired
    }

    def "can serialize and deserialize a spec with a flat classloader structure"() {

    private final String displayName;
    private final File projectCacheDir;

    public IsolatedParametersActionExecutionSpec(Class<? extends WorkAction<T>> implementationClass, String displayName, String actionImplementationClassName, Isolatable<T> isolatedParams, ClassLoaderStructure classLoaderStructure, File baseDir, File projectCacheDir, boolean usesInternalServices) {
        this.implementationClass = implementationClass;

            ProjectCacheDir projectCacheDir = getServices().get(ProjectCacheDir.class);
            ScalaCompilerFactory scalaCompilerFactory = new ScalaCompilerFactory(
                getServices().get(WorkerDirectoryProvider.class).getWorkingDirectory(),
                new ProcessIsolatedCompilerWorkerExecutor(workerDaemonFactory, actionExecutionSpecFactory, projectCacheDir), getScalaClasspath(),

    def classLoaderStructureProvider = Mock(ClassLoaderStructureProvider)
    def actionExecutionSpecFactory = Mock(ActionExecutionSpecFactory)
    def instantiator = Mock(Instantiator)
    def projectCacheDir = Mock(ProjectCacheDir)
    def classpathTransformer = Mock(CachedClasspathTransformer)
    DefaultWorkerExecutor workerExecutor

    def setup() {
        _ * executionQueueFactory.create() >> executionQueue

        _ * startParameter.watchFileSystemMode >> watchMode
        _ * startParameter.projectCacheDir >> null
        _ * startParameter.isWatchFileSystemDebugLogging() >> (watchLogging == WatchLogging.DEBUG)
        _ * startParameter.isVfsVerboseLogging() >> (vfsLogging == VfsLogging.VERBOSE)

        when:

            ClassPathRegistry classPathRegistry,
            ClassLoaderRegistry classLoaderRegistry,
            ActionExecutionSpecFactory actionExecutionSpecFactory,
            ProjectCacheDir projectCacheDir,
            InternalProblems problems
        ) {
            return new GroovyCompilerFactory(
                workerDaemonFactory,
                inProcessWorkerFactory,
                forkOptionsFactory,

    private final ClassLoader contextClassLoader;

    public FixedClassLoaderWorkerRequirement(File workerDirectory, File projectCacheDir, ClassLoader contextClassLoader) {
        super(workerDirectory, projectCacheDir);
        this.contextClassLoader = contextClassLoader;
    }

    public ClassLoader getContextClassLoader() {
        return contextClassLoader;
    }

            }
        """

        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: