}
        0 * _

        when:
        invalidate(snapshotInsideFirstWatchableHierarchy.absolutePath)
        then:
        1 * watcher.stopWatching({ equalIgnoringOrder(it, [watchableHierarchies[0]]) })
        0 * _

        when:
        buildFinished()
        then:
        0 * _

        when:
        addSnapshotInWatchableHierarchy(watchableHierarchies[0])
        then:

        def failure = new RuntimeException()

        when:
        expectSettingsBuiltWithFailure(failure)

        def controller = this.controller()
        controller.loadSettings()

        then:
        def t = thrown RuntimeException
        t == failure

        when:
        def finishResult = controller.finishBuild(null)

        then:

        expect:
        notStopped

        when: "stopped first time"
        coordinator.stop()

        then: "stops"
        stopped

        when: "requested again"
        coordinator.stop()

        then:
        stopped
        0 * _._
    }

    def "await idle timeout does nothing when already stopped"() {
        given:
        coordinator.stop()

        when:

	// InvalidPkgUse occurs when a package identifier is used outside of a
	// selector expression.
	//
	// Example:
	//  import "fmt"
	//
	//  var _ = fmt
	InvalidPkgUse

	// BadImportPath occurs when an import path is not valid.
	BadImportPath

	// BrokenImport occurs when importing a package fails.
	//
	// Example:
	//  import "amissingpackage"
	BrokenImport

    }

    def "runs action for transition when in from state"() {
        def action = Mock(Runnable)
        def controller = controller(TestState.A)

        when:
        asWorker {
            controller.transition(TestState.A, TestState.B, action)
        }

        then:
        1 * action.run()
        0 * _
    }

    def "runs action and returns result for transition when in from state"() {

        withProcessor(helperProcessor)
    }

    def "generated files are recompiled when annotated file changes"() {
        given:
        def a = java "@Helper class A {}"
        java "class Unrelated {}"

        outputs.snapshot { run "compileJava" }

        when:
        a.text = "@Helper class A { public void foo() {} }"
        run "compileJava"

        then:

        when:
        createRunner().build()

        then:
        def t = thrown(InvalidRunnerConfigurationException)
        t.message == 'Please specify a project directory before executing the build'
    }

    def "throws exception if working directory is not provided when run is requested"() {
        when:
        createRunner().run()

    def "invalidates cache when set of Gradle property defining system properties changes"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        settingsFile << """
            println(gradleProp + '!')
        """

        when:
        configurationCacheRun "help", "-D${SYSTEM_PROJECT_PROPERTIES_PREFIX}gradleProp=1"

        when:
        def mapped = provider.map(transform)

        then:
        0 * transform._

        when:
        def present = mapped.present

        then:
        present

        and:
        1 * transform.transform(someValue()) >> someOtherValue()
        0 * transform._

        when:
        def result = mapped.get()

        then:

    }

    def "exits when build fails with compile error"() {
        when:
        buildFile << """
            'script error
        """

        then:
        fails("a")
        exitContinuousBuildSinceNoDeclaredInputs()
    }

    def "exits when build fails with configuration error"() {
        when:
        buildFile << """
            throw new Exception("!")
        """