}

    public PartialBasicGradleProject getRootProject() {
        return rootProject;
    }

    public DefaultGradleBuild setRootProject(PartialBasicGradleProject rootProject) {
        this.rootProject = rootProject;
        this.buildIdentifier = new DefaultBuildIdentifier(rootProject.getRootDir());
        return this;
    }

    public Set<? extends PartialBasicGradleProject> getProjects() {

        settingsFile << """
            rootProject.name = 'app'
            include 'hello', 'log'
        """
        buildFile << """
            apply plugin: 'swift-application'
            application {
                source.from rootProject.file('Sources/App')
            }
            xctest {
                source.from rootProject.file('Tests/AppTests')
            }
            dependencies {

        settings.is(settings.settings)

        settings.settingsDir == settingsDir
        settings.rootProject.projectDir == settingsDir
        settings.rootDir == settingsDir

        settings.rootProject.parent == null
        settings.rootProject.projectDir.name == settings.rootProject.name
        settings.rootProject.buildFileName == Project.DEFAULT_BUILD_FILE
        settings.gradle.is(gradleMock)

        // Project is added as a side effect
        DefaultProjectDescriptor rootProject = new DefaultProjectDescriptor(null, "testName", TEST_DIR, registry, FILE_RESOLVER);

        assertSame(rootProject, registry.getProject(rootProject.getPath()));
        assertSame(rootProject, registry.getProject(rootProject.getProjectDir()));
    }

    @Test
    public void changeProjectDescriptorPath() {

    }

    def validateModel(GradleBuild model) {
        assert model.rootProject.name == 'test'
        assert model.rootProject.path == ':'
        assert model.rootProject.parent == null
        assert model.rootProject.children.size() == 2
        assert model.rootProject.children.every { it.parent == model.rootProject }
        assert model.projects*.name == ['test', 'a', 'b', 'c']

) {
    val gradleRootProject = when {
        project.name == "gradle" -> project.rootProject
        project.rootProject.name == "build-logic" -> rootProject.gradle.parent?.rootProject
        else -> project.gradle.parent?.rootProject
    }

    if (gradleRootProject != null && System.getenv("TEAMCITY_VERSION") != null) {
        val rootProjectName = rootProject.name
        val isInBuildLogic = rootProjectName == "build-logic"

        given:
        plugins.each { plugin -> buildFile << "apply plugin: '${plugin}'\n" }
        settingsFile << "rootProject.name = 'root'"

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        def natures = rootProject.projectNatures.collect{ it.id }

        then:
        if (plugins.contains('ear') && targetVersion < GradleVersion.version("8.0") ) {

        when:
        gradle.rootProject

        then:
        thrown IllegalStateException

        when:
        def rootProject = project('root')
        gradle.rootProject = rootProject

        then:
        gradle.rootProject == rootProject
    }

    def "root project action is executed when projects are loaded"() {
        given:

         .mutable()
         .attribute(Attribute.of('foo', String), 'value')
"""
    }

    def "fails to generate metadata for component with no variants"() {
        given:
        settingsFile << "rootProject.name = 'root'"
        buildFile << """
            apply plugin: 'maven-publish'

            group = 'group'
            version = '1.0'

            def comp = new TestComponent()

                }
            }
        """
        settingsFile << "rootProject.name = 'root'"

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        def buildCommands = rootProject.buildCommands

        then:
        rootProject.name == 'root'
        buildCommands.size() == 1
        buildCommands[0].name == 'buildCommandWithArguments'