}

        settingsFile << """
            include '${ANNOTATION_PROCESSOR_PROJECT_NAME}'
        """
        writeAnnotationProcessorProject()
    }

    def "compiler daemon is stopped when build is cancelled"() {
        given:
        buildFile << """
            plugins {
                id 'java'
            }
            ${dependsOnPidCapturingAnnotationProcessor}

    }

    /**
     * Registers a callback to be called just before the service represented by this provider is stopped.
     * The callback runs even if the service wasn't created.
     * This provider is used as a callback argument.
     * <p>
     * The service will only be stopped after completing all registered callbacks.
     *
     * @param stopAction the callback
     */

        file("app/controllers/Application.scala").text = original

        then:
        buildTriggeredAndSucceeded()

        and:
        appIsRunningAndDeployed()
    }

    def "play application is stopped when build is cancelled" () {
        when:
        succeeds("runPlay")

        then:
        appIsRunningAndDeployed()

        when:
        gradle.cancel()

        then:
        cancelsAndExits()

		return count == 2, nil
	}); err != nil {
		t.Fatalf("expected forget() to be called twice, first call from w.add() and then from w.Stop() called from w.processInterval(): %v", err)
	}

	if !w.stopped {
		t.Fatal("expected the watcher to be stopped but it wasn't")
	}
}

// TestCacheWatcherDrainingNoBookmarkAfterResourceVersionSent checks if the watcher's input

	// timerZombie is set when the timer has been stopped
	// but is still present in some P's heap.
	// Only set when timerHeaped is also set.
	// It is possible for timerModified and timerZombie to both
	// be set, meaning that the timer was modified and then stopped.
	// A timer sending to a channel may be placed in timerZombie
	// to take it out of the heap even though the timer is not stopped,
	// as long as nothing is reading from the channel.

/**
 * <p>A <code>StopActionException</code> is be thrown by a task {@link org.gradle.api.Action} or task action closure to
 * stop its own execution and to start execution of the task's next action. An action can usually be stopped by just
 * calling return inside the action closure. But if the action works with helper methods that can lead to redundant
 * code. For example:</p>
 *
 * <pre>

	// coherent. Since the world is stopped and sweeps are non-preemptible, we can never start
	// the world and see an unpaired sweep 'end' event. Other parts of the tracer rely on this.
	stw := stopTheWorld(stwStartTrace)

	// Prevent sysmon from running any code that could generate events.
	lock(&sched.sysmonlock)

	// Grab the minimum page heap address. All Ps are stopped, so it's safe to read this since

    }

    /**
     * Starts the daemon, receiving connections asynchronously (i.e. returns immediately).
     *
     * @throws IllegalStateException if this daemon is already running, or has already been stopped.
     */
    public void start() {
        LOGGER.info("start() called on daemon - {}", daemonContext);
        lifecycleLock.lock();
        try {
            if (stateCoordinator != null) {

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a service interface to indicate in which scopes it is defined in.
 * Services are lifecycled with their scope, and stopped/closed when the scope is closed.
 * <p>
 * Services are visible to other services in the same scope and descendent scopes.
 * Services are not visible to services in ancestor scopes.
 * <p>

        registration.add(UsedGradleVersions.class, usedGradleVersions);

        // register eagerly so stop() is triggered when services are being stopped
        GradleUserHomeCleanupService gradleUserHomeCleanupService = new GradleUserHomeCleanupService(deleter, gradleUserHomeDirProvider, cacheBuilderFactory, usedGradleVersions, buildOperationRunner, cacheConfigurations);