name.getCompileTaskName("cpp") == "compileCpp"
        name.getTaskName("link") == "link"
        name.dirName == "main/"
        name.withPrefix("compile") == "compile"
        name.withSuffix("implementation") == "implementation"

        name.append("debug").dirName == "main/debug/"
    }

    def "names for single dimension variant of main"() {
        expect:
        def name = Names.of("mainDebug")

version = '1.0'

// tag::add-to-manifest[]
jar {
    manifest {
        attributes("Implementation-Title": "Gradle",
                   "Implementation-Version": archiveVersion)
    }
}
// end::add-to-manifest[]

// tag::custom-manifest[]
def sharedManifest = java.manifest {
    attributes("Implementation-Title": "Gradle",
               "Implementation-Version": version)
}
tasks.register('fooJar', Jar) {
    manifest = java.manifest {

tasks.jar {
    manifest {
        attributes(
            "Implementation-Title" to "Gradle",
            "Implementation-Version" to archiveVersion
        )
    }
}
// end::add-to-manifest[]

// tag::custom-manifest[]
val sharedManifest = java.manifest {
    attributes (
        "Implementation-Title" to "Gradle",
        "Implementation-Version" to version
    )
}

tasks.register<Jar>("fooJar") {

                        }
                    }
                }
            }

            project(':a') {
                dependencies {
                    implementation project(':b')
                    implementation project(':c')
                }
            }

            abstract class MakeGreen implements TransformAction<Parameters> {
                interface Parameters extends TransformParameters {

    api(project(":hashing"))
    api(project(":base-services"))
    api(project(":messaging"))
    api(project(":native"))

    api(libs.jsr305)

    implementation(project(":files"))
    implementation(project(":logging"))

    implementation(libs.guava)
    implementation(libs.commonsIo)

    testImplementation(project(":process-services"))
    testImplementation(project(":core-api"))

    api(project(":stdlib-java-extensions"))
    api(project(":daemon-protocol"))
    api(project(":logging"))

    implementation(project(":core-api"))
    implementation(project(":messaging"))
    implementation(project(":concurrent"))
    implementation(project(":logging-api"))
    implementation(project(":problems-api"))

* Logging Implementation

 Maven 3.1.0 ships bundled with {{{https://www.slf4j.org/api/org/slf4j/simple/SimpleLogger.html}SLF4J simple logger}} and since 3.5.0 {{{../maven-slf4j-provider/}Maven-customized <<<maven-slf4j-provider>>>}},
 but is ready to use other logging implementations: SLF4J is responsible for loading the implementation, referred to as

    api(project(":file-collections"))
    api(project(":jvm-services"))
    api(project(":persistent-cache"))
    api(project(":core"))

    implementation(project(":logging"))
    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(libs.commonsIo)
    implementation(libs.commonsLang)

    testImplementation(testFixtures(project(":core")))

    testRuntimeOnly(project(":distributions-jvm")) {

    api(libs.asm)
    api(libs.javaPoet)
    api(libs.jsr305)

    implementation(libs.asmTree)
    implementation(libs.jacksonAnnotations)
    implementation(libs.jacksonDatabind)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":base-services"))
    implementation(project(":base-asm"))

    testCompileOnly(libs.jetbrainsAnnotations)

<2> The mapping method returns a download response wrapped in an `Optional`. If the resolver implementation can't provide a matching toolchain, the enclosing `Optional` contains an empty value.

== Register the resolver in a plugin

Use a settings plugin (`Plugin<Settings>`) to register the `JavaToolchainResolver` implementation:

.JavaToolchainResolverPlugin.java