def runner3 = Mock(BuildActionRunner)
    def runner = new ChainingBuildActionRunner([runner1, runner2, runner3])

    def "invokes runners until a result is produced"() {
        def action = Stub(BuildAction)
        def controller = Mock(BuildTreeLifecycleController)

        when:
        runner.run(action, controller)

        then:
        1 * runner1.run(action, controller) >> BuildActionRunner.Result.nothing()

                        text = gradle.gradleVersion
                    }
                }
            }
        """

        when:
        def runner = this.runner('writeVersion')
        configurer.execute(runner)
        runner.build()

        then:
        file("version.txt").text == version

        cleanup:
        killDaemons(version)

        where:

        when:
        runner.testGroup = "group"

        then:
        runner.testId == "if no test id is set, the test method name is used"
    }

    def "if test id is set, it is not replaced"() {
        when:
        runner.testGroup = "group"
        runner.testId = "Another id"

        then:
        runner.testId == "Another id"
    }

        when:
        runner.testProject = "test"

        then:
        runner.testId == "if no test id is set, the test method name is used"
    }

    def "if test id is set, it is not replaced"() {
        when:
        runner.testProject = "test"
        runner.testId = "Another id"

        then:
        runner.testId == "Another id"
    }

    }

    def "if test id is set, it is not replaced"() {
        when:
        runner.testGroup = "group"
        runner.testId = "Another id"

        then:
        runner.testId == "Another id"
    }

 * <p>
 * A Gradle runner can be used to functionally test build logic, by executing a contrived build.
 * Assertions can then be made on the outcome of the build, such as the state of files created by the build,
 * or what tasks were actually executed during the build.
 * <p>
 * A runner can be created via the {@link #create()} method.
 * <p>

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressedWithHighRelativeMedianDifference()
    }

    private setupRunner() {
        def iterations = determineIterations()
        runner.warmUpRuns = iterations
        runner.runs = iterations
    }

    private determineIterations() {

	runner := kubectlcmd.NewRunner(gConfig.RequestConcurrency)
	runner.ReportRunningTasks()
	if err := configLogs(logOpts); err != nil {
		return err
	}
	config, err := parseConfig()
	if err != nil {
		return err
	}
	clusterCtxStr := ""
	if config.Context == "" {
		var err error
		clusterCtxStr, err = content.GetClusterContext(runner, config.KubeConfigPath)
		if err != nil {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner

class GradleRunnerArgumentsIntegrationTest extends BaseGradleRunnerIntegrationTest {

    def "can execute build without specifying any arguments"() {
        given:
        buildScript """
            help {
                doLast {

            this.timeSupplier = timeSupplier;
            return this;
        }

        public Builder withRunner(BuildOperationRunner runner) {
            this.runner = runner;
            return this;
        }

        public Builder withWorkerLeaseService(WorkerLeaseService workerLeaseService) {
            this.workerLeaseService = workerLeaseService;