*
     * @param version the Java version
     */
    JvmEcosystemAttributesDetails withTargetJvmVersion(int version);

    /**
     * Expresses that variants which are optimized for standard JVMs should be preferred.
     */
    JvmEcosystemAttributesDetails preferStandardJVM();

    /**
     * Provides or requires the source files of a component.
     *
     * @return {@code this}
     */

        ])
        result.size() == 1
    }

    def "can parse output with no installations"() {
        given:
        def output = """
Unable to find any JVMs matching version "(null)".
Matching Java Virtual Machines (0):

Default Java Virtual Machines (0):

No Java runtime present, try --request to install.
"""
        when:

            } finally {
                requestCompleted(outcome);
            }
        } finally {
            httpExchange.close();
        }
    }

    // Dump all JVMs' threads on the machine to troubleshoot deadlock issues
    // We observed jstack hanging on windows, so for now we only enable it for Linux
    private void dumpThreadsUponTimeout(String stacktrace) {

 * 1. NOT DEPENDS ON ANY 3RD-PARTY LIBRARIES except JDK 11.
 * 2. UPDATE build-logic/lifecycle/src/main/kotlin/PrintStackTracesOnTimeoutBuildService.kt if this class is moved to another package.
 *
 * Used to print all JVMs' thread dumps on the machine. When it starts working, the process/machine might be in a bad state (e.g. deadlock),

        String name = toName(targetJvmEnvironment);
        switch (name) {
            case TargetJvmEnvironment.STANDARD_JVM:
                sb.append("standard JVMs");
                break;
            case TargetJvmEnvironment.ANDROID:
                sb.append("Android");
                break;
            default:
                sb.append(name);
        }
    }

If auto-detecting local toolchains is not sufficient or disabled, there are additional ways you can let Gradle know about installed toolchains.

If your setup already provides environment variables pointing to installed JVMs, you can also let Gradle know about which environment variables to take into account.

  - No variants exist.""")
    }

    public static final REPOSITORY_HINT = repositoryHint("Maven POM")

Using a Java lambda means that the bytecode uses invoke-dynamic instead of creating an actual sub-class.
The class for the invoke-dynamic instruction is generated at JVM runtime and Gradle cannot uniquely identify this class across different JVMs if the target functional interface is not serializable.
For task actions it is not a problem, because Gradle handles them in a special way.

The values are not case-sensitive.
+
_Default is `lifecycle` level._

`org.gradle.parallel=(true,false)`::
When configured, Gradle will fork up to `org.gradle.workers.max` JVMs to execute <<performance.adoc#parallel_execution,projects in parallel>>.
+
_Default is `false`._

`org.gradle.priority=(low,normal)`::

     Required by:
         project :
      > The consumer was configured to find a library for use during runtime, compatible with Java 11, packaged as a jar, preferably optimized for standard JVMs, and its dependencies declared externally, as well as attribute 'org.gradle.native.operatingSystem' with value 'windows'. There are several available matching variants of org.lwjgl:lwjgl:3.2.3