display = ParameterDisplay.PROMPT,
            allowEmpty = false,
            description = "The test project to use. E.g. largeJavaMultiProject"
        )
        param("channel", "adhoc")
        param("checks", "all")
        text("runs", "10", display = ParameterDisplay.PROMPT, allowEmpty = false)
        text("warmups", "3", display = ParameterDisplay.PROMPT, allowEmpty = false)
        text(
            "scenario",
            "",

        WorkerLoggingProtocol defaultProtocol = workerLoggingProtocol.getAndSet(newLoggingProtocol);
        try {
            return callable.call();
        } finally {
            workerLoggingProtocol.getAndSet(defaultProtocol);
        }
    }

    @Override
    public void onOutput(OutputEvent event) {

    @Deprecated
    @Override
    public final Provider<T> forUseAtConfigurationTime() {
        DeprecationLogger.deprecateMethod(Provider.class, "forUseAtConfigurationTime")
            .withAdvice("Simply remove the call.")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(7, "for_use_at_configuration_time_deprecation")
            .nagUser();
        return this;
    }

    @Override

        because("Kotlin soak tests use AssertJ")
    }

    integTestDistributionRuntimeOnly(project(":distributions-full"))
}

tasks.register("soakTest") {
    description = "Run all soak tests defined in the :soak subproject"
    group = "CI Lifecycle"
    dependsOn(":soak:forkingIntegTest")

            if (!versions.isEmpty()) {
                Preconditions.checkArgument(parsedGradleVersion.compareTo(versions.lastKey()) > 0,
                    "Gradle version (%s) must be greater than all previous versions: %s", parsedGradleVersion.getVersion(), versions.keySet());
                GradleVersion currentBaseVersion = GradleVersion.current().getBaseVersion();

    }

    /**
     * Measures elapsed time.
     *
     * Timers use System.nanoTime() to measure elapsed time,
     * and are therefore not synchronized with {@link #clock()} or the system wall clock.
     *
     * System.nanoTime() does not consider time elapsed while the system is in hibernation.
     * Therefore, timers effectively measure the elapsed time, of which the system was awake.
     */

            sources {
                c {
                    if (project.hasProperty("usePCH")) {
                        preCompiledHeader "pch.h"
                    }
                }
                binaries.all {
                    if (toolChain.name == "visualCpp") {
                        cCompiler.args("/showIncludes")
                    } else {
                        cCompiler.args("-H")
                    }

     * @since 5.6
     */
    WorkQueue processIsolation(Action<? super ProcessWorkerSpec> action);

    /**
     * Blocks until all work associated with the current build operation is complete.  Note that when using this method inside
     * a task action, it will block completion of the task action until all submitted work is complete.  This means that other

    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return Value.ofNullable(value.call());
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        when:
        setNanos(delta)

        then:
        clock.currentTime == START_MILLIS + Math.max(0, delta)

        where:
        delta << [0, 100, -100]
    }

    def "resyncs with system wall clock"() {
        when:
        setNanos(10)

        then:
        clock.currentTime == time(10)

        when:
        setNanos(15)

        then:
        clock.currentTime == time(15)