then:
        thrown(NullPointerException)
    }

    private BuildEnvironment loadBuildEnvironment(@ClosureParams(value = SimpleType, options = ["org.gradle.tooling.ModelBuilder"]) Closure config) {
        BuildEnvironment env
        withConnection {
            def builder = it.model(BuildEnvironment)
            config(builder)
            env = builder.get()
        }
        env
    }

                @Internal
                GradleBuildEnvironment buildEnvironment

                @Inject
                DaemonJudge(GradleBuildEnvironment buildEnvironment) {
                    this.buildEnvironment = buildEnvironment
                }

                @TaskAction
                void run() {
                    assert buildEnvironment.isLongLivingProcess() == ${daemon}
                }
            }

        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "configures the java settings"() {
        when:
        BuildEnvironment env = withConnection {
            def model = it.model(BuildEnvironment.class)
            model
                .setJvmArguments("-Xmx333m", "-Xms13m")
                .get()
        }

        then:
        env.java.javaHome

      | Creator: 	Project.<init>.tasks()
      | Rules:
         ⤷ PersonRules#createHelloTask(ModelMap<Task>, Person)
    + buildEnvironment
          | Type:   	org.gradle.api.tasks.diagnostics.BuildEnvironmentReportTask
          | Value:  	task ':buildEnvironment'
          | Creator: 	Project.<init>.tasks.buildEnvironment()
          | Rules:
             ⤷ copyToTaskContainer
    + components

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.build.BuildEnvironment;

public class FetchBuildEnvironment implements BuildAction<BuildEnvironment> {
    public BuildEnvironment execute(BuildController controller) {
        return controller.getModel(BuildEnvironment.class);
    }

import org.junit.Test


class EmbeddedKotlinProviderTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `no extra dependencies are added to the buildscript classpath`() {

        val result = build("buildEnvironment")

        assertThat(result.output, containsString("No dependencies"))
    }

    @Test
    fun `embedded kotlin dependencies are pinned to the embedded version`() {

        withBuildScript(

package org.gradle.integtests.tooling.r23

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import org.gradle.tooling.model.build.BuildEnvironment

class ModelBuilderCrossVersionSpec extends ToolingApiSpecification {

    def "empty list of tasks to execute when asking for BuildEnvironment is treated like null tasks and does not fail"() {
        projectDir.file('build.gradle') << """
            defaultTasks 'alpha'

            dependencies {
                val extension = when {
                    BuildEnvironment.isWindows -> "windows.zip"
                    BuildEnvironment.isMacOsX && BuildEnvironment.isIntel -> "mac.zip"
                    BuildEnvironment.isMacOsX && !BuildEnvironment.isIntel -> "mac_arm.zip"
                    BuildEnvironment.isLinux -> "linux.tar.gz"

        }

        then:
        tasks.size() > 0

        tasks.buildTreePath.every { it != null }
        tasks.buildTreePath.containsAll([":b1:buildEnvironment", ":b2:buildEnvironment"])
    }

    def "buildTreePath is available for tasks"() {
        given:
        includedBuild("b1")
        includedBuild("b2")

        when:
        def model = withConnection {

        then:
        UnsupportedVersionException e = thrown()
        e != null
    }

    def "partial BuildEnvironment"() {
        def connection = new UnsupportedOlderVersionConnection(connection, adapter)

        when:
        def buildEnv = connection.run(BuildEnvironment.class, parameters)

        then:
        buildEnv.gradle.gradleVersion == '1.0-milestoneX'
    }