it.details.pluginClass.startsWith("Plugin")
        }

        ops.size() == 3
        ops.find { it.details.buildPath == ":" }.details.pluginClass == "PluginRoot"
        ops.find { it.details.buildPath == ":a" }.details.pluginClass == "PluginA"
        ops.find { it.details.buildPath == ":b" }.details.pluginClass == "PluginB"
    }

        rootBuildOperation.result.buildPath == ":"

        def rootProject = rootBuildOperation.result.rootProject
        rootProject.path == ":"
        verifyProject(rootProject, 'root', ':', [':a'], testDirectory, 'root.gradle')
        verifyProject(project(":a", rootProject), 'a')

        def nestedBuildOperation = buildOperations[1]
        nestedBuildOperation.result.buildPath == ":nested"

        succeeds('help')

        then:
        operations().size() == 2
        verifySettings(operations()[0], settingsFile)
        operations()[0].details.buildPath == ":"
        verifySettings(operations()[1], nestedSettingsFile)
        operations()[1].details.buildPath == ":nested"
    }

    def 'can configure feature preview in settings'() {
        given:
        settingsFile << '''

        return fullPath(operationRecord.details.buildPath, operationRecord.details.projectPath)
    }

    private static String fullPath(String buildPath, String projectPath) {
        if (buildPath == ':') {
            return projectPath
        } else if (projectPath == ':') {
            return buildPath
        } else {
            return buildPath + projectPath
        }
    }

    }

    private static Spec<? super BuildOperationRecord> withPath(String buildPath, String taskPath) {
        return { (it.details.buildPath as String) == buildPath && (it.details.taskPath as String) == taskPath }
    }

    private static Spec<? super BuildOperationRecord> not(Spec<? super BuildOperationRecord> predicate) {

        private final Path buildPath;

        NotifyTaskGraphWhenReadyDetails(Path buildPath) {
            this.buildPath = buildPath;
        }

        @Override
        public String getBuildPath() {
            return buildPath.getPath();
        }

    }

            classes.doLast {
                def components = configurations.compileClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 2
                assert components[0].build.buildPath == ':buildB:buildSrc'
                assert components[0].build.name == 'buildSrc'
                assert components[0].build.currentBuild
                assert components[0].projectPath == ':'

        settings.getProjectRegistry().getAllProjects().forEach(project -> {
            if (project.getPath().equals(BUILD_SRC_PROJECT_PATH)) {
                Path buildPath = settings.getGradle().getIdentityPath();
                String suffix = buildPath == Path.ROOT ? "" : " (in build " + buildPath + ")";
                throw new GradleException("'" + SettingsInternal.BUILD_SRC + "' cannot be used as a project name as it is a reserved name" + suffix);

        assert op.descriptor.displayName == 'Configure project :project1'

        def details = op.descriptor.details as ConfigureProjectBuildOperationType.Details
        details.projectPath == ":project1"
        details.buildPath == ":"

        assertOpFailureOrNot(op, ConfigureProjectBuildOperationType.Result, failureCause)
    }

    static void assertBeforeEvaluateOp(TestBuildOperationRunner.Log.Record op, Throwable failureCause = null) {

        componentFilter { id -> id is ProjectComponentIdentifier && id.isSameBuild }
    }.files

    private
    val ProjectComponentIdentifier.isSameBuild: Boolean
        get() = build.buildPath == buildIdentifier.buildPath