/**
     * Indicates if a version selector can be used to short-circuit selection, whenever a different
     * version has been selected previously. Typically, an exact version selector can short-circuit,
     * in the sense that it will always return a correct answer whenever exposed to a version. But a
     * "latest" selector will give a different answer whether is called first, or starting with a
     * pre-selected version.
     *

     * This method does not access the file system.
     * It is agnostic to whether a given file object represents a regular file, directory or does not exist.
     * That is, the term “file” is used in the java.io.File sense, not the regular file sense.
     *
     * @param files the site of files to find the encompassing roots of
     * @return the encompassing roots
     */

        }

        @Override
        public void visitDependencies(TaskDependencyResolveContext context) {
            throw new UnsupportedOperationException();
        }
    }

    // "partial" in the sense that some artifacts are only available as a File, and have no metadata
    private static class PartialSelectedArtifactSet implements SelectedArtifactSet {
        private final List<?> elements;

     * the build script can sneak in such {@code Entry} and change the result of e.g. {@code contains}
     * call. The external world cannot influence the result, so it makes no sense to record such access
     * as an input to the configuration cache.
     * <p>
     * Note that the returned object doesn't have to be the same object that was passed to the method.
     *
     * @param o the object to cast

     * lazily, for example calling {@code JvmLanguageUtilities#useDefaultTargetPlatformInference(Configuration, TaskProvider)}.
     * For consumers, it makes sense to specify a specific version of JVM they target.
     *
     * @param version the Java version
     */
    JvmEcosystemAttributesDetails withTargetJvmVersion(int version);

    /**

import org.junit.Assume

@TargetGradleVersion(">=3.0")
class M9JavaConfigurabilityCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "uses defaults when a variant of empty jvm args requested"() {
        when:
        def env = withConnection {

        builder.setBaseName("Gradle Worker Daemon");
        builder.setLogLevel(loggingManager.getLevel()); // NOTE: might make sense to respect per-compile-task log level
        builder.sharedPackages("org.gradle", "javax.inject");
        if (forkOptions.getClassLoaderStructure() instanceof FlatClassLoaderStructure) {

// 2) Use the breaker here.
// 3) Compare table size and performance of using the more generic breaker.
//
// Note that we can extend the current algorithm to be much more accurate. This
// only makes sense, though, if the performance and/or space penalty of using
// the generic breaker is big. Extra data will only be needed for non-cased
// runes, which means there are sufficient bits left in the caseType.

    public static String formatDurationVeryTerse(long duration) {
        if (duration == 0) {
            return "0s";
        }

        StringBuilder result = new StringBuilder();

        // Whereas it doesn't make sense to pass negative values to this method,
        // the duration passed on call sited is often a result of some math, what is not guarantees positive-values-only.

import org.gradle.util.GradleVersion
import spock.lang.Issue
import spock.lang.Timeout

class JavaConfigurabilityCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "configures the java settings"() {
        when:
        BuildEnvironment env = withConnection {