when:
        def cacheResult = execution.completeAndGet()

        then:
        cacheResult.get() == delegateOutput

        delegateResult.getOutputAs(_ as Class) >> Try.successful(delegateOutput)
        delegateResult.reusedOutputOriginMetadata >> Optional.of(originMetadata)

        1 * delegate.execute(work, context) >> delegateResult

    public WorkspaceResult(CachingResult parent, @Nullable File workspace) {
        super(parent);
        this.workspace = workspace;
    }

    @Override
    public <T> Try<T> getOutputAs(Class<T> type) {
        return getExecution()
            .map(execution -> execution.getOutput(workspace))
            .map(type::cast);
    }

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

    private
    val catalogExtensionBaseType = typeOf<ExternalModuleDependencyFactory>()

            assert context.workspace == workspace
            return delegateResult
        }
        0 * _

        when:
        def output = result.getOutputAs(Object)

        then:
        output.get() == delegateOutput
        1 * delegateExecution.getOutput(workspace) >> delegateOutput
        0 * _
    }

        }

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

        when:
        def resolvedResult = result.getOutputAs(Object)

        then:
        resolvedResult.get() == resolvedDelegateResult

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

    }

    private <T> IdentityCacheResult<T> executeInCache(UnitOfWork work, C context) {
        R result = execute(work, context);
        return new DefaultIdentityCacheResult<>(
            result
                .getOutputAs(Object.class)
                .map(Cast::<T>uncheckedNonnullCast),
            result
                .getReusedOutputOriginMetadata()
                .orElseGet(() -> result.getAfterExecutionOutputState()

        /**
         * Get the output of the work. For immutable work this is resolved from the immutable workspace.
         */
        // TODO Parametrize UnitOfWork with this type
        <T> Try<T> getOutputAs(Class<T> type);

        /**
         * A list of messages describing the first few reasons encountered that caused the work to be executed.
         * An empty list means the work was up-to-date and hasn't been executed.

                        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.