}

    @EqualsAndHashCode
    static class ScopeIds {
        final UniqueId buildInvocation
        final UniqueId workspace
        final UniqueId user

        ScopeIds(UniqueId buildInvocation, UniqueId workspace, UniqueId user) {
            this.buildInvocation = buildInvocation

    def "exposes scans view of scope IDs"() {
        when:
        buildScript """
            def ids = project.gradle.services.get($BuildScanScopeIds.name)
            println "ids: [buildInvocation: \$ids.buildInvocationId, workspace: \$ids.workspaceId, user: \$ids.userId]"
        """
        succeeds("help")

        then:
        def buildInvocationId = scopeIds.buildInvocationId.asString()

        then:
        assertIdsAreShared(scopeIds.ids(1), scopeIds.ids(0))
    }

    void assertIdsAreShared(ScopeIdsFixture.ScopeIds earlier, ScopeIdsFixture.ScopeIds current) {
        assert current.buildInvocation != earlier.buildInvocation
        assert current.workspace == earlier.workspace
        assert current.user == earlier.user
    }

        executer.buildInvocation().launcherJvmArgs.contains(debugArgument)
    }

    def "start launcher process in debugger options"() {
        when:
        executer.startLauncherInDebugger {
            it.server = false
            it.host = "myHost"
        }

        then:
        def launcherArgs = executer.buildInvocation().launcherJvmArgs

        }
        result
    }

    @CompileDynamic
    private OutputScrapingExecutionResult executeInContainer() {
        def invocation = buildInvocation()
        container.withEnv(invocation.environmentVars.collectEntries { k, v -> [k, v]})
        def containerResult = container.execute(["/gradle-under-test/bin/gradle", *invocation.args] as String[])
        def result

    }

    @Override
    public void assertCanExecute() throws AssertionError {
        if (!getDistribution().isSupportsSpacesInGradleAndJavaOpts()) {
            Map<String, String> environmentVars = buildInvocation().environmentVars;
            for (String envVarName : Arrays.asList("JAVA_OPTS", "GRADLE_OPTS")) {
                String envVarValue = environmentVars.get(envVarName);
                if (envVarValue == null) {

    }

    @Override
    protected Factory<JavaExecHandleBuilder> getExecHandleFactory() {
        return () -> {
            NativeServicesTestFixture.initialize();
            GradleInvocation invocation = buildInvocation();
            JavaExecHandleBuilder builder = TestFiles.execFactory().newJavaExec();
            builder.workingDir(getWorkingDir());
            builder.setExecutable(new File(getJavaHomeLocation(), "bin/java"));

        return requireOwnGradleUserHomeDir();
    }

    public File getUserHomeDir() {
        return userHomeDir;
    }

    protected GradleInvocation buildInvocation() {
        validateDaemonVisibility();

        GradleInvocation gradleInvocation = new GradleInvocation();
        gradleInvocation.environmentVars.putAll(environmentVars);

 * to either {@link org.gradle.tooling.BuildLauncher#forTasks(Iterable)} or {@link org.gradle.tooling.BuildLauncher#forLaunchables(Iterable)}.</p>
 *
 * @since 1.12
 */
public interface BuildInvocations extends Model, ProjectModel {

    /**
     * Returns the identifier for the Gradle project that these invocations originate from.
     *
     * @since 2.13
     */
    @Override

import org.gradle.tooling.model.gradle.BuildInvocations;

public class FetchTaskSelectorsBuildAction implements BuildAction<BuildInvocations> {
    private final String projectName;

    public FetchTaskSelectorsBuildAction(String projectName) {
        this.projectName = projectName;
    }

    public BuildInvocations execute(BuildController controller) {