.build.gradle.kts
[source,kotlin]
----
plugins {
    alias(libs.plugins.jetbrains.intellij)
}
----

TIP: `jetbrains-intellij` is available as the Gradle generated safe accessor: `jetbrains.intellij`.

[.text-right]

        if (e instanceof SocketException || (e instanceof SSLException && e.getMessage().contains("readHandshakeRecord"))) {
            return new HttpRequestException("Got socket exception during request. It might be caused by SSL misconfiguration", e);
        }

        if (!(e instanceof SSLHandshakeException)) {
            return e;
        }

        SSLHandshakeException sslException = (SSLHandshakeException) e;

    def "handles different target gradle versions concurrently"() {
        given:
        def last = new ReleasedVersionDistributions().getMostRecentRelease()
        // When adding support for a new JDK version, the previous release might not work with it yet.
        Assume.assumeTrue(last.worksWith(Jvm.current()))
        assert dist != last
        println "Combination of versions used: current - $dist, last - $last"

     *
     * <p>The wrapper downloads a certain distribution only once and caches it. If your distribution base is the
     * project, you might submit the distribution to your version control system. That way no download is necessary at
     * all. This might be in particular interesting, if you provide a custom gradle snapshot to the wrapper, because you
     * don't need to provide a download server then.
     */
    @Input

                  - Provides org.gradle.usage 'java-api'
----

All _compatible_ candidate variants are displayed with their attributes.

* Unmatched attributes are presented first, as they might be the missing piece in selecting the proper variant.
* Compatible attributes are presented second as they indicate what the consumer wanted and how these variants do match that request.

For example, a property that specifies the output directory for a compilation task may start with a value specified by a plugin.
Then a build script might change the value to some custom location, then this value is used by the task when it runs.
However, once the task starts to run, we want to prevent further property changes.

    }

    def "sorts by comparing ProjectComponentSelector on left and ModuleComponentSelector on right"() {
        def d1 = newDependency(TestComponentIdentifiers.newSelector(":hisProject"), DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("org.gradle", "zzzz"), "3.0"))

Still, conceptually such modules can contain different variants or might have dependency constraints they just omitted (or wrongly defined as dependencies).
In the next sections, we explore a number existing oss modules with such incomplete metadata and the rules for adding the missing metadata information.

// limitations under the License.

[[build_services]]
= Using Shared Build Services

Shared build services allow tasks to share state or resources.
For example, tasks might share a cache of pre-computed values or use a web service or database instance.

A build service is an object that holds the state for tasks to use.

* The map returned by `TaskInputs.getProperties()` is now unmodifiable.
  Trying to modify it will result in an `UnsupportedOperationException` being thrown.
* There are slight changes in the incubating <<dependency_capability_conflict.adoc#sub:selecting-between-candidates,capabilities resolution>> API, which has been introduced in 5.6, to also allow variant selection based on variant name

[[changes_5.6]]