when:
        String output1 = runBuild { launcher -> launcher.withArguments("-P$ARG_1").addArguments("-P$ARG_2") }

        then:
        output1.toString().contains(ARG_1)
        output1.toString().contains(ARG_2)

        when:
        String output2 = runBuild { launcher -> launcher.withArguments("-P$ARG_1").addArguments(["-P$ARG_2" as String]) }

        then:

                    implementation rootProject
                }
            }
        """

        when:
        withConnection {
            def builder = it.model(List)
            builder.withArguments("--parallel")
            collectOutputs(builder)
            return builder.get()
        }

        then:

                executer.noDeprecationChecks()
            }
            fileToTest.text = sample
            executer
                .withTasks('help')
                .withArguments("--stacktrace", "--init-script", settingsEvaluatedHook.absolutePath)
            beforeSample(file, tagSuffix)
            executer.run()
            fileToTest.delete()
        }
    }

        (TaskSuccessResult)events.operations[0].result
    }

    private void runCacheableBuild(listener) {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments("--build-cache").forTasks('cacheable').addProgressListener(listener, EnumSet.of(OperationType.TASK)).run()
        }
    }

        if (AGP_VERSIONS.isAgpNightly(agpVersion)) {
            def init = AGP_VERSIONS.createAgpNightlyRepositoryInitScript()
            extraArgs += ["-I", init.canonicalPath]
        }
        return runner.withArguments([runner.arguments, extraArgs].flatten())
            .ignoreDeprecationWarningsIf(AGP_VERSIONS.isOld(agpVersion), "Old AGP version")
    }

        jar.assertHasNotChangedSince(snapshot);

        sleep 1000 // Some filesystems (ext3) have one-second granularity for lastModified, so bump the time to ensure we can detect a regenerated file
        executer.withArguments("--rerun-tasks").withTasks("jar").run();

        jar.assertHasChangedSince(snapshot);
        snapshot = jar.snapshot();

        executer.withTasks("jar").run();
        jar.assertHasNotChangedSince(snapshot);

        // We need to set the SSL properties as arguments here even for non-embedded test mode
        // because we want them to be set on the wrapper client JVM, not the daemon one
        wrapperExecuter.withArguments(keyStore.getTrustStoreArguments())
        server.configure(keyStore)
        server.withBasicAuthentication(DEFAULT_USER, DEFAULT_PASSWORD)
        server.start()

        file("build.gradle") << """
    task hello {

        )
        SantaTrackerConfigurationCacheWorkaround.beforeBuild(checkoutDir, homeDir)
        // Use --continue so that a deterministic set of tasks runs when some tasks fail
        runner.withArguments(runner.arguments + "--continue")
        def result = runner.buildAndFail()

        then:
        if (GradleContextualExecuter.isConfigCache()) {
            result.assertConfigurationCacheStateStored()

        }

        file('settings.gradle') << "include ${(1..projectCount).collect { "'${createProjectName(it)}'" }.join(',')}"

        when:
        // Build everything first
        mostRecentReleaseExecuter.withArguments(arguments)
        result = runWithMostRecentFinalRelease(JAR_TASK_NAME)

        then:
        javaProjects.each { javaProject ->
            javaProject.mainClassFile.assertIsFile()

        then:
        outputContains("foo")
        configurationCache.assertStateLoaded()

        when:
        def commandLineArgs = commandLine.split("\\s+")
        executer.withArguments(commandLineArgs)
        configurationCacheRun "myTask"

        then:
        outputContains("bar")