file("build.gradle") << """
        description = project.getProperty('theDescription')
"""

        when:
        GradleProject project = withConnection { ProjectConnection it ->
            it.model(GradleProject).withArguments('-PtheDescription=heyJoe').get()
        }

        then:
        project.description == 'heyJoe'
    }

    def "understands system properties"() {

        when:
        def ideaProject = loadIdeaProjectModel()
        def gradleProject = ideaProject.modules.find({ it.name == 'root' }).gradleProject

        then:
        ideaProject.javaLanguageSettings.jdk != null
        ideaProject.javaLanguageSettings.jdk.javaVersion == JavaVersion.current()
        ideaProject.javaLanguageSettings.jdk.javaHome.toString() == gradleProject.description
    }

            dependencies {
                implementation project(':a')
            }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject).children.find { it.gradleProject.path == ':b' }

        then:
        project.projectDependencies.size() == 1
        project.projectDependencies[0].classpathAttributes.find { it.name == 'without_test_code' }.value == "true"
    }

import java.io.File;
import java.io.Serializable;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

/**
 * Structurally implements {@link org.gradle.tooling.model.GradleProject} model.
 */
public class DefaultGradleProject implements Serializable, GradleProjectIdentity {
    private final DefaultGradleScript buildScript = new DefaultGradleScript();
    private File buildDirectory;

        and:
        assertHasConfigureSuccessfulLogging()
        result.assertNotOutput(prefix)
    }

    def "runs settings scripts and does not configure projects when action queries GradleProject model"() {
        setupBuild()

        when:
        def model = withConnection {
            def executer = action(new FetchGradleBuildAction())
            collectOutputs(executer)
            executer.run()

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.BlockingHttpServer
import org.gradle.tooling.model.GradleProject
import org.junit.Rule

class IsolatedProjectsToolingApiParallelConfigurationIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {
    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

        setup:
        def connector = toolingApi.connector()
        ProjectConnection connection = connector.connect()
        connection.getModel(GradleProject)
        connector.disconnect()

        when:
        connection.getModel(GradleProject)

        then:
        def e = thrown(RuntimeException)
        e.message ==~ /Cannot use .* as it has been stopped./
    }

class DisabledTaskExecutionOnIncludedBuildsCrossVersionSpec extends ToolingApiSpecification {

    @TargetGradleVersion('>=3.3 <6.8')
    def "Can't launch tasks from included builds via launchables obtained from GradleProject model"() {
        setup:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                includeBuild 'includedBuild'
            """
        }

        then:
        rootProject.javaSourceSettings.jdk != null
        rootProject.javaSourceSettings.jdk.javaVersion == JavaVersion.current()
        rootProject.javaSourceSettings.jdk.javaHome.toString() == rootProject.gradleProject.description
    }

    def "target bytecode level respects explicit targetCompatibility configuration"() {
        given:
        buildFile << """
        apply plugin:'java'

        when:
        CustomModel customModel = withConnection { it.action(new FetchCustomModel()).run() }

        then:
        customModel.gradle.name == "hello-world"
        customModel.eclipse.gradleProject.name == "hello-world"

        when:
        IdeaProject ideaModel = withConnection { it.action(new FetchIdeaModel()).run() }

        then:
        ideaModel.name == "hello-world"