connector
    }

    def startBusyDaemon() {
        def daemonNum = daemonCounter++
        DaemonContext context = new DefaultDaemonContext(daemonNum.toString(), javaHome, JavaLanguageVersion.current(), javaHome, daemonNum, 1000, [], false, NativeServicesMode.ENABLED, DaemonParameters.Priority.NORMAL)
        def address = createAddress(daemonNum)

    }

    def "cannot run a build when build is configured to use Java 7 or earlier"() {
        given:
        projectDir.file("gradle.properties").writeProperties("org.gradle.java.home": jdk.javaHome.absolutePath)

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            connection.newBuild().run()
        }

        then:
        GradleConnectionException e = thrown()

     | 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)) {

        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());
    }