containsSuccessfulProjectConfigurationOperation(":buildSrc:a", file("buildSrc"), ":a")
        containsSuccessfulProjectConfigurationOperation(":", projectDir, ":")
        containsSuccessfulProjectConfigurationOperation(":b", projectDir, ":b")
        containsSuccessfulProjectConfigurationOperation(":included", file("included"), ":")
        containsSuccessfulProjectConfigurationOperation(":included:c", file("included"), ":c")

    @Deprecated
    protected GradleExecuter usingBuildFile(File file) {
        return getExecuter().usingBuildScript(file);
    }

    protected GradleExecuter usingProjectDir(File projectDir) {
        return getExecuter().usingProjectDirectory(projectDir);
    }

    protected ArtifactBuilder artifactBuilder() {
        GradleExecuter gradleExecuter = new InProcessGradleExecuter(distribution, testDirectoryProvider);

                if (!archive.exists()) {
                    builder(archiveContentsDir.usingNativeTools(), archive)
                }
                File target = new File(invocationSettings.projectDir, name)
                FileUtils.copyFile(archive, target)
            }
        }
    }

    private static BuildMutator linkToArchiveContents(InvocationSettings invocationSettings, File source) {

        IdeaProject project = loadToolingModel(IdeaProject)
        def module = project.children[0]

        then:
        module.contentRoots.size() == 1
        module.contentRoots[0].rootDirectory == projectDir
        module.parent instanceof IdeaProject
        module.parent == project
        module.parent == module.project
        module.children.empty
        module.description == null

        includedBuildSrc.includedBuilds.empty
        includedBuildSrc.editableBuilds.empty
    }

    def "can query model for multi-project buildSrc builds"() {
        multiProjectBuildSrc(projectDir)
        settingsFile << """
            includeBuild("child")
        """

        def childBuild = file("child")
        multiProjectBuildSrc(childBuild)

        given:

            this.invocation = invocation
        }

        @Override
        void beforeScenario(ScenarioContext context) {
            def buildFile = new File(invocation.projectDir, "build.gradle")
            buildFile << """
                def finalizerTask = tasks.register("testFinalizer")
                subprojects {

            result.output.contains('${answerOutput(true)}')
        """)

        then:
        succeeds 'build', '-i'
        executedAndNotSkipped ':test'
        new JUnitXmlTestExecutionResult(projectDir).totalNumberOfTestClassesExecuted > 0
    }

    def "cannot capture user input if standard in was not provided"() {
        when:
        file("src/test/groovy/Test.groovy") << functionalTest("""

     */
    private
    fun projectSchemaFor(plugins: PluginRequests): Try<TypedProjectSchema> {
        val projectDir = uniqueTempDirectory()
        val startParameter = projectSchemaBuildStartParameterFor(projectDir)
        return createNestedBuildTree("$path:${projectDir.name}", startParameter, services).run { controller ->
            controller.withEmptyBuild { settings ->
                Try.ofFailable {

            type: KaCapturedType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            typeRenderer.typeProjectionRenderer.renderTypeProjection(analysisSession, type.projection, typeRenderer, printer)
        }
    }

    public object AS_CAPTURED_TYPE_WITH_PROJECTION : KaCapturedTypeRenderer {
        override fun renderType(
            analysisSession: KaSession,

        when:
        EclipseProject model = withConnection { connection ->
            return connection.action(new LoadEclipseModel(eclipseWorkspace([
                project("root", projectDir),
                gradleProject("a"),
                project("explicitName", file("b"))
            ]))).run()
        }

        then: