return projects.allProjects.map { project ->
            val mutableModel = project.mutableModel
            if (relevantProjects.contains(project)) {
                mutableModel.layout.buildDirectory.finalizeValue()
                ProjectWithWork(project.projectPath, mutableModel.projectDir, mutableModel.buildFile, mutableModel.layout.buildDirectory.asFile.get(), mutableModel.normalization.computeCachedState())
            } else {

        override val isRootBuild: Boolean
            get() = state is RootBuildState

        override val gradle: GradleInternal
            get() = state.mutableModel

        override val hasScheduledWork: Boolean
            get() = gradle.taskGraph.size() > 0

        override val scheduledWork: ScheduledWork
            get() {

        buildProjectRegistry.getProject(_) >> childProjectState
        childProjectState.mutableModel >> childProject

        when:
        buildLoader.load(settingsInternal, gradle)

        then:
        1 * rootProjectClassLoaderScope.createChild(_, _) >> childProjectClassLoaderScope
        1 * rootProjectState.mutableModel >> rootProject

        build1.parent >> rootBuild

        includedBuildState1.mutableModel >> build1

        includedBuildState2.projects >> projects2
        includedBuildState2.buildRootDir >> dir2
        includedBuildState2.importableBuild >> true

        build2.includedBuilds() >> []
        build2.parent >> rootBuild

        includedBuildState2.mutableModel >> build2

        // Currently, there is no public API to do this in a project isolation safe way. Instead, do this in a non-safe way for now
        (project as ProjectInternal).owner.owner.projects.rootProject.mutableModel.plugins.apply(KotlinScriptRootPlugin::class.java)
        tasks.register("kotlinDslAccessorsReport", PrintAccessors::class.java)
    }
}


abstract class KotlinScriptRootPlugin : Plugin<Project> {

        expect:
        rootState.mutableModel == rootProject
        state.mutableModel == project
    }

    def "cannot query mutable project instance when not set"() {
        given:
        def build = build("p1", "p2")

        def state = registry.stateFor(projectId("p1"))

        when:
        state.mutableModel

        then:
        def e = thrown(IllegalStateException)

        def actualBuilder = registry.locateForClientOperation("model", false, projectState)

        then:
        builder1.canBuild("model") >> false
        builder2.canBuild("model") >> true
        projectState.mutableModel >> project
        projectState.displayName >> Describables.of("<project>")

        when:
        def result = actualBuilder.build(null)

        then:
        result == "result"

        and:

        includedBuild.buildRootDir >> buildDefinition.buildRootDir
        includedBuild.identityPath >> idPath
        includedBuild.buildIdentifier >> buildIdentifier
        includedBuild.mutableModel >> gradle

        gradle.services >> services

        services.get(PublicBuildPath) >> Stub(PublicBuildPath)

        target.ensureProjectsLoaded()

        val schemaBuilder = GradleProcessInterpretationSchemaBuilder(softwareTypeRegistry)

        val settings = target.mutableModel.settings
        val settingsContext = LoadedSettingsScriptContext(settings, settings.classLoaderScope, settings.settingsScript)

        val settingsSequence = schemaBuilder.getEvaluationSchemaForScript(settingsContext)

        !filter.isSatisfiedBy(excluded)
        filter.isSatisfiedBy(notExcluded)
    }

    ProjectState project(String path, ProjectInternal model) {
        def state = Stub(ProjectState)
        state.mutableModel >> model
        return state
    }

    def task(ProjectInternal project, String name) {
        def task = Stub(TaskInternal) {
            getProject() >> project
            getName() >> name