public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

    @Override
    public void removeCallback(Runnable cancellationHandler) {
        cancellationToken.removeCallback(cancellationHandler);
    }

    public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

    @Override
    public void removeCallback(Runnable cancellationHandler) {
        cancellationToken.removeCallback(cancellationHandler);
    }

    @Override
    public void cancel() {
        throw new UnsupportedOperationException();
    }

    boolean addCallback(Runnable cancellationHandler);

    /**
     * Removes a callback called when cancellation request happens.
     *
     * @param cancellationHandler removed callback.
     */
    void removeCallback(Runnable cancellationHandler);

    /**
     * Removes a callback from a set of handlers called when cancel is requested.
     *
     * @param cancellationHandler removed callback.
     */
    void removeCallback(Runnable cancellationHandler);

            }
        };
    }

    public void start() {
        cancellationToken.addCallback(cancellationCallback);
    }

    @Override
    public void stop() {
        cancellationToken.removeCallback(cancellationCallback);
    }

        Runnable interrupt = thread::interrupt;
        try {
            cancellationToken.addCallback(interrupt);
            return delegate.execute(work, context);
        } finally {
            cancellationToken.removeCallback(interrupt);
            if (cancellationToken.isCancellationRequested()) {
                Thread.interrupted();
                throw new BuildCancelledException("Build cancelled while executing " + work.getDisplayName());

            buildCancellationToken.addCallback(cancellationCallback);
        }
    }

    @Override
    public void stop() {
        if (started.compareAndSet(true, false)) {
            buildCancellationToken.removeCallback(cancellationCallback);
        }
    }

    @NonNullApi
    private class KillWorkers implements Runnable {
        @Override
        public void run() {

            }
        } catch (InterruptedException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        } finally {
            cancellationToken.removeCallback(cancellationHandler);
        }
    }

    public boolean hasBeenTriggered() {
        return changeArrived;
    }

    public void notifyFileChangeArrived() {
        changeArrived = true;

        result.assertNormalExitValue()
        1 * buildCancellationToken.addCallback(_) >> {
            assert it[0].class == ExecHandleShutdownHookAction
            true
        }
        1 * buildCancellationToken.removeCallback(_) >> {
            assert it[0].class == ExecHandleShutdownHookAction
            true
        }
    }

    void "waiting for process returns quickly if process already completed"() {
        given:

        1 * connection.dispatch({ it instanceof CloseInput })
        1 * connection.dispatch({ it instanceof Finished })
        1 * cancellationToken.cancellationRequested >> true
        1 * cancellationToken.removeCallback(_)
        1 * connection.stop()
        0 * _
    }

    def "tries to find a different daemon if connected to a stale daemon address"() {
        def resultMessage = Stub(BuildActionResult)