import org.gradle.internal.jvm.Jvm

apply plugin: "java"

sourceSets {
    taglet
}

dependencies {
    if (Jvm.current().toolsJar) {
        tagletImplementation files(Jvm.current().toolsJar)
    }
}

javadoc {
    dependsOn tagletClasses
    options {
        locale = 'de_DE'
        breakIterator = true
        taglets 'LocaleAwareTaglet'
        tagletPath sourceSets.taglet.java.destinationDirectory.get().asFile

package org.gradle.api.attributes.java;

import org.gradle.api.Named;
import org.gradle.api.attributes.Attribute;

/**
 * Represents the target JVM environment. Typically, a standard JVM or Android.
 * This attribute can be used by libraries to indicate that a certain variant is better suited for
 * a certain JVM environment. It does however NOT strictly require environments to match, as the

    | org.gradle.usage               | java-api | java-api     |
    | org.gradle.dependency.bundling |          | external     |
    | org.gradle.jvm.environment     |          | standard-jvm |
    | org.gradle.jvm.version         |          | 8            |'''

        expect:
        normalizer.normalize(originalOutput, null) == '''
    | Attribute Name                 | Provided | Requested    |

 */
package org.gradle.launcher.daemon.context


import org.gradle.internal.jvm.JavaInfo
import org.gradle.internal.jvm.Jvm
import org.gradle.internal.nativeintegration.services.NativeServices
import org.gradle.internal.os.OperatingSystem
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.jvm.toolchain.JvmImplementation
import org.gradle.jvm.toolchain.JvmVendorSpec
import org.gradle.launcher.daemon.configuration.DaemonParameters

import org.gradle.api.JavaVersion;
import org.gradle.api.tasks.compile.CompileOptions;
import org.gradle.internal.Factory;
import org.gradle.internal.jvm.Jvm;
import org.gradle.jvm.toolchain.JavaInstallationMetadata;
import org.gradle.jvm.toolchain.internal.JavaExecutableUtils;

import javax.annotation.Nullable;
import java.io.File;

                }
            }
        """
    }

    def runWithToolchainConfigured(Jvm jvm) {
        result = executer
            .withArgument("-Porg.gradle.java.installations.paths=" + jvm.javaHome.absolutePath)
            .withTasks("check", "javadoc")
            .run()
    }

    private static String testClass(String className) {

 */

package org.gradle.jvm.toolchain.internal;

import org.gradle.internal.jvm.Jvm;
import org.gradle.jvm.toolchain.JavaLanguageVersion;

import javax.inject.Inject;

public abstract class CurrentJvmToolchainSpec extends DefaultToolchainSpec {

    @Inject
    public CurrentJvmToolchainSpec() {
        getLanguageVersion().set(JavaLanguageVersion.of(Jvm.current().getJavaVersion().getMajorVersion()));

        then:
        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Client JVM system properties appear in the build if withSystemProperties() is not called"() {
        when:
        runTask()

        then:
        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Client JVM system properties do not appear in the build if withSystemProperties() is called"() {

            ${mavenCentralRepository()}
        """
    }

    private void writeBuildFileWithToolchainsFromJavaPlugin(Jvm jvm) {
        writeBuildFile()
        configureJavaPluginToolchainVersion(jvm)
    }

    private void writeBuildFileWithToolchainsFromCheckstyleTask(Jvm jvm) {
        writeBuildFile()
        buildFile << """
            tasks.withType(Pmd) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.jvm.toolchain.internal

import org.gradle.internal.jvm.Jvm
import spock.lang.Specification

class CurrentInstallationSupplierTest extends Specification {

    def "supplies java home as installation"() {
        given: