def includedSelector = invocations[0].taskSelectors[0]

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedSelector)
        }

        then:
        thrown(BuildException)

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedTask)
        }

        then:

        when:
        file("gradle.properties") << "org.gradle.workers.max=12"
        def result = withBuild()

        then:
        result.standardOutput.contains("max workers: 12")
    }

    def "can specify options using command-line arguments"() {
        when:
        def result = withBuild { BuildLauncher launcher ->
            launcher.withArguments("--max-workers", "12")
        }

        then:

        TaskSelector selectorT2 = model.taskSelectors.find { it.name == 't2' }
        def result = withBuild { BuildLauncher it ->
            it.forLaunchables(selectorT1, selectorT2)
        }
        then:
        result.result.assertTasksExecutedInOrder(':t1', ':b:c:t1', ':b:t2', ':b:c:t2')

        when:
        result = withBuild { BuildLauncher it ->
            it.forLaunchables(selectorT2, selectorT1)
        }

    @Issue("GRADLE-2635")
    def "can configure build file name and logging"() {
        file('buildX.gradle') << "logger.info('info message')"

        when:
        def out = withBuild { it.withArguments('-b', 'buildX.gradle', '-i') }.standardOutput

        then:
        out.contains('info message')
    }

    //below was working as expected

            }
            model = model.withBuild(build);
        }
        Reporting reporting = model.getReporting();
        if (reporting != null) {
            expandReport(reporting.getPlugins());
        }
        return model.withBuild(build);
    }

    private List<Plugin> expandPlugin(List<Plugin> oldPlugins) {

        file("build.gradle") << """
        logger.debug("debugging stuff")
        logger.info("infoing stuff")
"""

        when:
        String debug = withBuild { it.withArguments('-d') }.standardOutput

        and:
        String info = withBuild { it.withArguments('-i') }.standardOutput

        then:
        debug.count("debugging stuff") == 1
        debug.count("infoing stuff") == 1

        and:

            assert gradle.includedBuilds.empty
        """)
        includeBuild(buildB)
        def buildC = singleProjectBuild("buildC") {
        }
        validationTask(buildA.buildFile, "withBuild", """
            assert gradle.includedBuild("buildB").name == "buildB"
            assert gradle.includedBuild("buildC").name == "buildC"
            assert gradle.includedBuild("buildC").projectDir == file('${buildC.toURI()}')

        file("impl/build.gradle") << "task bar(dependsOn: ':api:foo')"
        file("other/build.gradle") << "assert false: 'should not be evaluated'"

        when:
        withBuild { it.forTasks(":impl:bar") }

        then:
        noExceptionThrown()
    }

        Model m = model.withPreserveModelVersion(true);
        assertEquals("4.1.0", new MavenModelVersion().getModelVersion(m));
    }

    @Test
    void testV4ModelPriority() {
        Model m = model.withBuild(Build.newInstance()
                .withPlugins(Collections.singleton(Plugin.newInstance()
                        .withExecutions(Collections.singleton(

        when:
        runDumpTaskWithTapi()

        then:
        agentWasNotApplied()
    }

    private void runDumpTaskWithTapi() {
        withConnection {
            buildOutput = withBuild {
                it.forTasks("hello")
            }.stdout.toString()
        }
    }

    private void agentWasApplied() {
        agentStatusWas(true)
    }

    private void agentWasNotApplied() {