}
        }
    }

    private ProgressEvents runBuild(String task, Set<OperationType> operationTypes) {
        ProgressEvents events = ProgressEvents.create()
        runBuild(task, events, operationTypes)
        events
    }

    private Object runBuild(String task, ProgressListener listener, Set<OperationType> operationTypes) {
        withConnection {

        """

        when:
        runBuild('b')

        then:
        task(':a').originPlugin.displayName == "build.gradle"
        task(':b').originPlugin.displayName == "script.gradle"
    }

    def "reports task origin for binary plugins"() {
        given:
        buildFile << """
            apply plugin: 'java'
        """

        when:
        runBuild('build')

        then:

        // The main operations; there may be others
        def runBuild = events.operation("Run build")
        runBuild.descriptor.parent == null
        runBuild.failed
        runBuild.failures.size() == 1

        def configureBuild = events.operation("Configure build")
        configureBuild.descriptor.parent == runBuild.descriptor
        configureBuild.successful

        """
        file("included/settings.gradle") << """
            include 'c'
        """
    }

    def "reports successful project configuration progress events"() {
        when:
        runBuild("tasks")

        then:
        events.operations.size() == 6
        events.trees == events.operations
        containsSuccessfulProjectConfigurationOperation(":buildSrc", file("buildSrc"), ":")

                }
            }
        """

        when:
        runBuild('writeFile')

        then:
        with (taskSuccessResult(':writeFile')) {
            !upToDate
            !executionReasons.empty
        }

        when:
        runBuild('writeFile')

        then:
        with (taskSuccessResult(':writeFile')) {
            upToDate

    def "Adding zero arguments is a no-op"() {
        expect:
        runBuild { launcher -> launcher.addArguments() }
    }

    def "Adding null argument throws NPE"() {
        when:
        runBuild { launcher -> launcher.addArguments(null as String) }

        then:
        thrown(NullPointerException)

        when:
        runBuild { launcher -> launcher.addArguments(null as List) }

        then:

        """

        when:
        runBuild(':compileJava')

        then:
        task(':compileJava').dependencies == tasks(':included:jar')
    }

    @TargetGradleVersion('>=3.0 <5.1')
    def "throws UnsupportedMethodException for task dependencies when target version does not support it"() {
        when:
        runBuild('tasks')

        and:
        task(':tasks').dependencies

        when:
        runBuild {
            succeeds()
            cancel()
        }

        then:
        !result.output.contains("ctrl-d")
        result.output.contains(waitingMessage)
    }

    def "after cancelling a continuous build, we can subsequently run another"() {
        when:
        withConnection {
            runBuild {
                succeeds()
                cancel()

    def "can run continuous build with tooling api"() {
        when:
        def javaSrcFile = sourceDir.file("Thing.java") << 'public class Thing {}'

        then:
        runBuild {
            succeeds()
            waitBeforeModification javaSrcFile
            javaSrcFile.text = 'public class Thing { public static final int FOO=1; }'
            succeeds()
        }
    }

                }
            }
        """
    }

    def "reports successful transform progress events"() {
        given:
        withFileSizerTransform()

        when:
        runBuild("resolve")

        then:
        def transformOperation = events.operation(applyTransform("FileSizer"))
        with(transformOperation) {
            assertIsTransform()