* @since 5.0
     */
    LongRunningOperation addJvmArguments(String... jvmArguments);

    /**
     * Sets system properties to pass to the build.
     * <p>
     * By default, the Tooling API passes all system properties defined in the client to the build. If called, this method limits the system properties that are passed to the build, except for
     * immutable system properties that need to match on both sides.
     * <p>

    const val GRADLE_INSTALL_PATH = "gradle_installPath"


    /**
     * Specify the flaky test quarantine strategy:
     *
     * -PflakyTests=include: run all tests, including flaky tests.
     * -PflakyTests=exclude: run all tests, excluding flaky tests.
     * -PflakyTests=only: run flaky tests only.
     *
     * Default value (if absent) is "include".
     */
    const val FLAKY_TEST = "flakyTests"

     *
     * <ul>
     *
     * <li>All calls to {@link Dispatch#dispatch(Object)} for outgoing messages have returned.</li>
     *
     * <li>All dispatches to handlers have completed.</li>
     *
     * <li>All internal threads have completed.</li>
     *
     * </ul>
     */
    @Override
    public void stop() {
        try {

 *
 * You must apply the `gradlebuild.kotlin-dsl-plugin-bundle-integ-tests` plugin for this to work.
 *
 * You can also set the `kotlinDslTestsExtraRepo` system property
 * to the path of a maven repository to be injected in all tests.
 * This is useful for testing new/development Kotlin versions.
 */
abstract class AbstractKotlinIntegrationTest : AbstractIntegrationTest() {

    protected
    open val injectLocalTestRepositories = true

To stop running Daemon processes, use the following command:

----
$ gradle --stop
----

This terminates all Daemon processes started with the same version of Gradle used to execute the command.

You can also kill Daemons manually with your operating system.
To find the PIDs for all Daemons regardless of Gradle version, see <<gradle_daemon.adoc#find_all_daemons,Find Daemons>>.

[[sec:daemon_jvm_criteria]]

                }
                handlers.clear();
                completed = true;
            }
            if (!failures.isEmpty()) {
                throw new DefaultMultiCauseException("Failed to handle all HTTP requests.", failures);
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void resetExpectations() {
        cancelBlockedRequests();

        """
    }

    @Issue("https://github.com/gradle/gradle/issues/5510")
    @Ignore("All lambdas are becoming serializable")
    // TODO remove this test if the change making all lambdas serializable is not reverted
    def "task with nested property defined by non-serializable Java lambda fails the build"() {
        // With configuration cache, all lambdas are forced to be serializable, so there won't be anything to report.

                recordTopLevelModules(details);
            }
        }));

        // create our own metaInf which runs after mainSpec's files
        // this allows us to generate the deployment descriptor after recording all modules it contains
        CopySpecInternal metaInf = (CopySpecInternal) getMainSpec().addChild().into("META-INF");
        CopySpecInternal descriptorChild = metaInf.addChild();

====
<1> Applies the plugin to the project
<2> Configures the URL to be verified through the exposed extension

Executing the `verifyUrl` task renders a success message if the HTTP GET call to the configured URL returns with a 200 response code:

[[verify-url-cmd-output]]
[source,shell]
----
$ gradle verifyUrl

include::{snippetsPath}/developingPlugins/testingPlugins/tests/verifyUrl.out[]
----

Executing a task will result in task dependencies being executed, as well as those tasks required to build dependency artifacts from other included builds.

You can call a task in an included build using a fully qualified path, for example, `:included-build-name:project-name:taskName`.
Project and task names can be <<command_line_interface.adoc#sec:name_abbreviation,abbreviated>>.

----