}

        0 * _._
    }

    def "cancelBuild when running command completes in short time"() {
        def command = Mock(Runnable)

        expect:
        notStopped

        when:
        coordinator.runCommand(command, "command")
        start {
            thread.blockUntil.running
            coordinator.cancelBuild()
        }

        then:

        startBuild(task, buildCacheEnabled)
        cancelBuild(task)

        startBuild(task, buildCacheEnabled)
        cancelBuild(task)

        assert daemons.daemons.size() == 1
    }

    private void assertTaskIsCancellable(String task, boolean buildCacheEnabled = false) {
        startBuild(task, buildCacheEnabled)
        cancelBuild(task)

        def handler = blockingHttpServer.expectAndBlock("/block")

        when:
        startBuild("compileJava")

        then:
        handler.waitForAllPendingCalls()

        then:
        cancelBuild()

        then:
        daemons.daemon.becomesIdle()

        and:
        pidFile().exists()
        def pid1 = pidFile().text.strip() as long
        new ProcessFixture(pid1).waitForFinish()

            @Override
            public void run() {
                LOGGER.info("HandleCancel processing {}", execution.getCommand());
                execution.getDaemonStateControl().cancelBuild();
            }
        });
        try {
            execution.proceed();
        } finally {
            execution.getConnection().onCancel(null);
        }
    }

     * doesn't finnish in a timely manner a request for forceful stop will be issued ({@link #requestForcefulStop(String reason)}.</p>
     */
    void cancelBuild();

    /**
     * Returns a cancellation token used to communicate cancel requests to commands processed in this daemon.
     *

                requestForcefulStop("the build was canceled after a stop was requested");
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void cancelBuild() {
        requestCancel();

        lock.lock();
        try {
            while (true) {
                try {
                    switch (state) {
                        case Idle:

	_, ret := m[key]
	return ret
}

func XTestParentFinishesChild(t testingT) {
	// Context tree:
	// parent -> cancelChild
	// parent -> valueChild -> timerChild
	// parent -> afterChild
	parent, cancel := WithCancel(Background())
	cancelChild, stop := WithCancel(parent)
	defer stop()
	valueChild := WithValue(parent, "key", "value")
	timerChild, stop := WithTimeout(valueChild, veryLongDuration)

}

func (ccc *customCauseContext) cancel() {
	ccc.mu.Lock()
	ccc.err = Canceled
	close(ccc.done)
	cancelChild := ccc.cancelChild
	ccc.mu.Unlock()

	if cancelChild != nil {
		cancelChild()
	}
}

func (ccc *customCauseContext) setCancelChild(cancelChild CancelFunc) {
	ccc.cancelChild = cancelChild
}

func TestCustomContextCause(t *testing.T) {