}

    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"() {

    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:
        succeeds ":customTask", "-PoutputDir=build/output1"
        then:
        executedAndNotSkipped ":customTask"

        when:
        succeeds ":customTask", "-PoutputDir=build/output2"
        then:
        executedAndNotSkipped ":customTask"

        when:
        succeeds ":customTask", "-PoutputDir=build/output1"
        then:

        when:
        runWithInput("generate", prompt, "value")

        then:
        result.assertTaskNotSkipped(":generate")
        file("build/out.txt").text == "value"

        when:
        runWithInput("generate", prompt, "value")

        then:
        result.assertTaskSkipped(":generate")

        when:
        runWithInput("generate", prompt, "")

        given:
        list.add('b')

        when:
        list.add(0, 'a')
        list.add(2, 'c')

        then:
        list == ['a', 'b', 'c']
    }

    def "fires events when element is added at index"() {
        Action<String> action = Mock()

        given:
        list.all(action)

        when:
        list.add(0, 'a')
        list.add(0, 'b')

        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("!")
        """

    def "downloads deleted files again when they are referenced"() {
        given:
        buildscriptWithDependency(snapshotModule)

        when:
        succeeds 'resolve'

        then:
        def jarFile = findFile(cacheDir, "files-*/**/*.jar")

        when:
        assert jarFile.delete()

        and:
        succeeds 'resolve'

        !container.hasPlugin("x")
        !container.findPlugin("x")
    }

    def "fails when getting unknown plugin"() {
        when:
        container.getPlugin("unknown")

        then:
        thrown(UnknownPluginException)
    }

    def "fails when getting plugin of unknown type"() {
        when:
        container.getPlugin(plugin1Class)

        then:
        thrown(UnknownPluginException)

        when:
        loggingManager.start()

        then:
        1 * loggingRouter.addStandardOutputListener(stdoutListener)

        when:
        loggingManager.removeStandardOutputListener(stdoutListener)

        then:
        1 * loggingRouter.removeStandardOutputListener(stdoutListener)

        when:
        loggingManager.stop()

        then:

    void 'cannot create task with no name'() {
        when:
        container.create([:])

        then:
        InvalidUserDataException e = thrown()
        e.message == "The task name must be provided."
    }

    void 'can create task with dependencies'() {
        def task = task("task")
        taskFactory.create(_ as TaskIdentity) >> task

        when: