}

        then:
        immutableWorkspace.file("output.txt").text == "output"
        0 * _

        when:
        def resolvedResult = result.getOutputAs(Object)

        then:
        resolvedResult.get() == resolvedDelegateResult

        1 * delegateExecution.getOutput(immutableWorkspace) >> resolvedDelegateResult
        0 * _
    }

                        internalOptions,
                        transformFactoryForLegacy
                    )
                )
                .execute()
                .getOutputAs(File::class.java)
                .get()
        } catch (e: CacheOpenException) {
            throw e.cause as? ScriptCompilationException ?: e
        }

                    workspaceProvider,
                    asyncIO
                )
                executionEngine.createRequest(work)
                    .execute()
                    .getOutputAs(AccessorsClassPath::class.java)
                    .get()
            }


    private
    fun configuredProjectSchemaOf(scriptTarget: Any, classLoaderScope: ClassLoaderScope): TypedProjectSchema? {

            transformFactoryForLegacy,
            scriptCompilationHandler
        );
        return getExecutionEngine(target)
            .createRequest(unitOfWork)
            .execute()
            .getOutputAs(GroovyScriptCompilationOutput.class)
            .get();
    }

    /**
     * We want to use build cache for script compilation, but build cache might not be available yet with early execution engine.

        }
    }

    private void executeWork(UnitOfWork work) {
        ExecutionEngine.Result result = engine.createRequest(work).execute();
        GeneratedAccessors accessors = result.getOutputAs(GeneratedAccessors.class).get();
        ClassPath generatedClasses = DefaultClassPath.of(accessors.classesDir);
        sources = sources.plus(DefaultClassPath.of(accessors.sourcesDir));

            library.getRuntimeFile().set(runtimeFile);
            library.getOutputs().from(library.getLinkFile());
            library.getOutputs().from(library.getRuntimeFile());
        });
    }

    private void addTasksForComponentWithStaticLibrary(final TaskContainer tasks, final DirectoryProperty buildDirectory, SoftwareComponentContainer components) {

      parallel_execute_op.getOperation()->getNumResults());

  for (auto& execute : executes)
    parallel_execute_outputs.append(execute.getOutputs().begin(),
                                    execute.getOutputs().end());

  for (auto result :
       llvm::zip(island_op.getOutputs(), parallel_execute_outputs))
    std::get<0>(result).replaceAllUsesWith(std::get<1>(result));

    PerformanceTest() {
        getJvmArgumentProviders().add(new PerformanceTestJvmArgumentsProvider())
        getOutputs().doNotCacheIf("baselines contain version 'flakiness-detection-commit', 'last' or 'nightly'", { containsSpecialVersions() })
        getOutputs().doNotCacheIf("flakiness detection", { flakinessDetection })
        getOutputs().upToDateWhen { !containsSpecialVersions() && !flakinessDetection }

        projectName.set(project.name)

  auto new_while_wrapper =
      CreateIsland(new_while_op, while_wrapper.getControlInputs(), builder);
  for (auto result : while_wrapper.getOutputs()) {
    result.replaceAllUsesWith(
        new_while_wrapper.getOutputs()[result.getResultNumber()]);
  }
  while_wrapper.getControl().replaceAllUsesWith(new_while_wrapper.getControl());
  while_wrapper.erase();
  return new_while_op;
}

        }

        return taskCacheabilityResolver.shouldDisableCaching(
            task,
            context.getTaskProperties(),
            task.getOutputs().getCacheIfSpecs(),
            task.getOutputs().getDoNotCacheIfSpecs(),
            detectedOverlappingOutputs
        );
    }

    @Override
    public boolean isAllowedToLoadFromCache() {