result = mostRecentReleaseExecuter.withTasks(tasks).run()
        result
    }

    static String createProjectName(int projectNo) {
        "project$projectNo"
    }

    ): Boolean {
        if (typeArguments.isEmpty()) return false
        if (!visited.add(this)) return true
        for (projection in typeArguments) {
            // E.g., Test : Comparable<Test>
            val type = (projection as? ConeKotlinTypeProjection)?.type ?: continue
            // E.g., Comparable<Test>
            val newType = substituteOrNull(type) ?: continue

            assert buildPath == ':'
            assert rootProject.projectDir == rootDir.absolutePath
            assert rootProject.buildFile == rootDir.file("build.gradle").absolutePath
        }
        with(projectsIdentified[1].details) {
            assert buildPath == childBuild
            assert rootProject.projectDir == childDir.absolutePath

                void addTask(ModelMap<Task> tasks, Props p) {
                    tasks.create('printResolvedValues') {
                        doLast {
                            String projectDirPath = project.projectDir.absolutePath
                            String relative
                            String relativeExpected

                            assert p.theFile1

                id('java-library')
            }
            allprojects {
                println("project name = " + name)
                println("project path = " + path)
                println("project projectDir = " + projectDir)
                println("project rootDir = " + rootDir)
                println("project toString = " + it)
                it.name
                project.name
                project.path

        given:
        goodCode()

        and:
        buildFile << """
            dependencies {
                file("\$projectDir/lib/").mkdirs()
                implementation files((1..999).collect {
                    createJarFile("\$projectDir/lib/library\${it}.jar")
                })
            }

            def createJarFile(String libraryPath) {
                def fos

include('p1')
include('p1:p11')
includeBuild('another')"""
        file("p1").mkdir()
        file('another/settings.gradle') << ""

        when:
        projectDir("p1")
        run "projects"

        then:
        outputDoesNotContain "another"
    }

    def "included builds are only rendered if there are some"() {
        when:
        run "projects"

        0 * _
    }

    def "starts watching when missing file is created"() {
        def rootDir = file("root").createDir()
        def watchableHierarchy = rootDir.file("a/b/projectDir")
        def missingFile = watchableHierarchy.file("c/missing.txt")

        when:
        registerWatchableHierarchies([watchableHierarchy])
        addSnapshot(missingFileSnapshot(missingFile))
        then:

        task.classpath.files == project.sourceSets.test.runtimeClasspath.files
        task.testClassesDirs.contains(project.sourceSets.test.java.destinationDirectory.get().asFile)
        task.workingDir == project.projectDir
    }

    def "applies mappings to tasks added by the build script"() {
        given:
        project.pluginManager.apply(JavaPlugin)

        when:

        '''
            task fooJar(type: Jar) {
                archiveBaseName = 'c-foo'
                destinationDirectory = projectDir
            }
            task barJar(type: Jar) {
                archiveBaseName = 'c-bar'
                destinationDirectory = projectDir
            }
            artifacts {
                foo fooJar
                bar barJar
            }
        '''
    }