What would have happened if Gradle was limited to _only Java 11_ at the time?

## Decision

1. The Gradle distribution will never include a Java runtime.
   Instead, Gradle will leverage Java toolchains for the Daemon and worker processes.

        this.version = version;
    } // -- void setVersion( String )

    /**
     * Gets the identifier of the extension.
     *
     * @return The extension id in the form {@code <groupId>:<artifactId>:<version>}, never {@code null}.
     */
    public String getId() {
        StringBuilder id = new StringBuilder(128);

        id.append((getGroupId() == null) ? "[unknown-group-id]" : getGroupId());
        id.append(":");

  <name>Guava InternalFutureFailureAccess and InternalFutures</name>
  <description>
    Contains
    com.google.common.util.concurrent.internal.InternalFutureFailureAccess and
    InternalFutures. Most users will never need to use this artifact. Its
    classes are conceptually a part of Guava, but they're in this separate
    artifact so that Android libraries can use them without pulling in all of

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.BeforeEach;

   * is not guaranteed to return zero when the dataset consists of the same value multiple times,
   * due to numerical errors. However, it is guaranteed never to return a negative result.
   *
   * <h3>Non-finite values</h3>
   *
   * <p>If the dataset contains any non-finite values ({@link Double#POSITIVE_INFINITY}, {@link

   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code

   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code

     *
     * @param artifact The artifact whose available versions should be determined, must not be {@code null}.
     * @return The available versions of the artifact or an empty list if none, never {@code null}.
     * @since 3.0-alpha-3
     */
    List<String> findVersions(Artifact artifact);

    /**

   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code

    assertFalse(
        "Maps of different sizes should not be equal.", getMap().equals(newHashMap(moreEntries)));
  }

  public void testEquals_list() {
    assertFalse(
        "A List should never equal a Map.", getMap().equals(copyToList(getMap().entrySet())));
  }

  private static <K, V> Map<K, V> newHashMap(
      Collection<? extends Entry<? extends K, ? extends V>> entries) {