| Detected by:        {description}SourceSupplier{normal}

""")
    }

    def "jdk is rendered properly"() {
        given:
        File javaHome = new File(temporaryFolder, "javahome").tap { mkdirs() }
        def metadata = JvmInstallationMetadata.from(
            javaHome,
            "1.8.0", "adoptopenjdk",
            "runtimeName", "1.8.0-b01",
            "jvmName", "25.292-b01", "jvmVendor",
            "myArch"

        file('build.gradle') << """
        description = org.gradle.internal.jvm.Jvm.current().javaHome.toString()
        """

        when:
        BuildEnvironment env = withConnection { it.getModel(BuildEnvironment.class) }
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        env.java.javaHome.toString() == project.description
    }

    }

    def "uses current jdk if not specified otherwise"() {
        Assume.assumeTrue(fileLockingIssuesSolved())
        given:
        goodCode()
        writeBuildFile()

        when:
        succeeds("pmdMain")

        then:
        outputContains("Running pmd with toolchain '${Jvm.current().javaHome.absolutePath}'")
    }

        javaCompile.destinationDirectory.fileValue(temporaryFolder.createDir())
        def javaHomeFile = temporaryFolder.createFile("javaHome")

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.javaHome = javaHomeFile
        javaCompile.createSpec()

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)

        Xpp3Dom javahome = dom != null ? dom.getChild(JavaToolchainImpl.KEY_JAVAHOME) : null;
        if (javahome == null) {
            throw new MisconfiguredToolchainException(
                    "Java toolchain without the " + JavaToolchainImpl.KEY_JAVAHOME + " configuration element.");
        }
        Path normal = Paths.get(javahome.getValue()).normalize();
        if (Files.exists(normal)) {

                newMetadata(javaInstallationLocation, languageVersion, vendor)
            }
        }
    }

    private def newMetadata(InstallationLocation javaHome, String languageVersion, String vendor = "") {
        def location = javaHome.location
        if (location.name.contains("broken")) {
            return JvmInstallationMetadata.failure(location, "errorMessage")
        }

    }

    def "uses current jdk if not specified otherwise"() {
        given:
        goodCode()
        writeDummyConfig()
        writeBuildFile()

        when:
        succeeds("checkstyleMain")

        then:
        outputContains("Running checkstyle with toolchain '${Jvm.current().javaHome.absolutePath}'")
    }

        writeRuleFile()
        writeBuildFileWithToolchainsFromJavaPlugin(jdk)

        when:
        succeeds("codenarcMain")

        then:
        outputContains("Running codenarc with toolchain '${jdk.javaHome.absolutePath}'.")
    }

    def "uses jdk from toolchains set through codenarc task"() {
        given:
        def jdk = setupExecutorForToolchains()

abstract class TaskThatRequiresJavaHome : DefaultTask() {

    @get:Internal
    abstract val javaHome: DirectoryProperty

    @get:Inject
    protected abstract val execOps: ExecOperations

    @TaskAction
    fun action() {
        val outputBytes = ByteArrayOutputStream()
        val javaExecutable = javaHome.file("bin/java")
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath

    public Set<InstallationLocation> get() {
        return Collections.singleton(asInstallation(Jvm.current().getJavaHome()));
    }
    private InstallationLocation asInstallation(File javaHome) {
        return InstallationLocation.autoDetected(javaHome, getSourceName());
    }