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 * _
    }

    }

    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.

        assertEquals("B1", itemList.get(1).getOutputs()[0]);
        assertFalse(itemList.get(1).isUpdated());

        assertEquals(1, itemList.get(2).getInputs().length);
        assertEquals(2, itemList.get(2).getOutputs().length);
        assertEquals("c1", itemList.get(2).getInputs()[0]);
        assertEquals("C1", itemList.get(2).getOutputs()[0]);
        assertEquals("C2", itemList.get(2).getOutputs()[1]);

        assertEquals("a", synonymItem.getInputs()[0]);
        assertEquals("A", synonymItem.getInputs()[1]);
        assertEquals(2, synonymItem.getOutputs().length);
        assertEquals("b", synonymItem.getOutputs()[0]);
        assertEquals("B", synonymItem.getOutputs()[1]);
        assertNull(synonymItem.getNewInputs());
        assertNull(synonymItem.getNewOutputs());
        assertFalse(synonymItem.isUpdated());

    }

    protected abstract class LibraryOutputs implements MinimalFileSet, Buildable {
        @Override
        public final Set<File> getFiles() {
            if (hasOutputs()) {
                return getOutputs();
            }
            return Collections.emptySet();
        }

        @Override
        public final TaskDependency getBuildDependencies() {
            if (hasOutputs()) {

        binary.binaryInputs(task.getOutputs().getFiles().getAsFileTree().matching(new PatternSet().include("**/*.obj", "**/*.o")));

        PreCompiledHeader pch = binary.getPrefixFileToPCH().get(sourceSet.getPrefixHeaderFile());
        pch.setPchObjects(task.getOutputs().getFiles().getAsFileTree().matching(new PatternSet().include("**/*.pch", "**/*.gch")));
        pch.builtBy(task);