"deferred -> completed"  | Deferrable.deferred { 5 } | { input -> Deferrable.completed(input + 25) }   | false           | false
        "completed -> deferred"  | Deferrable.completed(5)   | { input -> Deferrable.deferred { input + 25 } } | false           | true
        "completed -> completed" | Deferrable.completed(5)   | { input -> Deferrable.completed(input + 25) }   | true            | true
    }

        given:
        def property = propertyWithProducer()
        def provider = property.filter { it.contains("1") }

        when:
        provider.isPresent()

        then:
        def ex = thrown(InvalidUserCodeException)
        ex.message == "Querying the filtered value of <prop> before <task> has completed is not supported"
    }

        given:
        def property = propertyWithProducer()
        def provider = property.map { Integer.parseInt(it) }

        when:
        provider.isPresent()

        then:
        def ex = thrown(InvalidUserCodeException)
        ex.message == "Querying the mapped value of <prop> before <task> has completed is not supported"
        0 * progressEventEmitter._

    /**
     * Called when the cache is due to be unlocked. Call after other threads have completed work. This method may access the cache files.
     */
    void finishWork();

    /**
     * Called just before the cache is to be unlocked. Called after all work has been completed, and after {@link #finishWork()} has completed.
     * This method should not modify the cache files.
     */

        def a = profile.getTaskProfile("foo:a").completed(Stub(TaskState)).setStart(100).setFinish(300)
        def b = profile.getTaskProfile("foo:b").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def c = profile.getTaskProfile("foo:c").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def d = profile.getTaskProfile("foo:d").completed(Stub(TaskState)).setStart(301).setFinish(302)

        expect:

            getSkipped() >> false
            getDidWork() >> false
        }

        expect:
        new TaskExecution("a").completed(skipped).status == "Skipped for a good reason."
        new TaskExecution("a").completed(busy).status == ""
        new TaskExecution("a").completed(noWork).status == TaskExecution.NO_WORK_MESSAGE
    }

import org.gradle.internal.service.ServiceRegistry;

class DefaultBuildSessionContext implements BuildSessionContext {
    private final ServiceRegistry sessionScopeServices;
    private boolean completed;

    public DefaultBuildSessionContext(ServiceRegistry sessionScopeServices) {
        this.sessionScopeServices = sessionScopeServices;
    }

    @Override
    public ServiceRegistry getServices() {

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed.
     */
    @Override
    void stop();

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed. Once the given
     * timeout has been reached, forcefully stops remaining jobs and throws an exception.
     *

        profile.getProjectProfile("a").getTaskProfile("a:x").completed(Stub(TaskState)).setStart(100).setFinish(300)
        profile.getProjectProfile("b").getTaskProfile("b:x").completed(Stub(TaskState)).setStart(300).setFinish(300)
        profile.getProjectProfile("c").getTaskProfile("c:x").completed(Stub(TaskState)).setStart(300).setFinish(300)
        profile.getProjectProfile("d").getTaskProfile("d:x").completed(Stub(TaskState)).setStart(301).setFinish(302)

                .apply(Deferrable.this.completeAndGet())
                .completeAndGet()));
    }

    /**
     * An already completed result, can be successful or failed.
     */
    static <T> Deferrable<T> completed(T successfulResult) {
        return new Deferrable<T>() {
            @Override
            public Optional<T> getCompleted() {
                return Optional.of(successfulResult);