}
        """

        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:

        when:
        loggingManager.start()

        then:
        1 * loggingRouter.addStandardOutputListener(stdoutListener)

        when:
        loggingManager.removeStandardOutputListener(stdoutListener)

        then:
        1 * loggingRouter.removeStandardOutputListener(stdoutListener)

        when:
        loggingManager.stop()

        then:

    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'

        given:
        gradle.attachSettings(state)

        when:
        gradle.resetState()

        then:
        1 * state.close()
    }

    def "get root project throws exception when root project is not available"() {
        when:
        gradle.rootProject

        then:
        thrown IllegalStateException

        when:
        def rootProject = project('root')

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

        access.open()
        access.close()

        then:
        1 * cleanupExecutor.cleanup()
        0 * _
    }

    def "does not clean up on close when clean up has already occurred"() {
        def access = newAccess(OnDemand)

        when:
        access.open()
        access.cleanup()

        then:
        1 * cleanupExecutor.cleanup()
        0 * _

        when:

        result.assertTasksNotSkipped(":a", ":b")

        when:
        outputFileB.delete()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":b")
        result.assertTasksSkipped(":a")

        when:
        succeeds "b"

        then:
        result.assertTasksSkipped(":a", ":b")
    }

    def "skips task when output dir contents are up-to-date"() {

    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: