// This is not really correct: the IdeaProject for including build should contain all IDEA modules
        // However, it appears that IDEA 2017 depends on this behaviour, and iterates over the included builds to get all modules
        allProjects.rootIdeaProject.name == 'buildA'
        allProjects.rootIdeaProject.modules.collect { it.name } == ['buildA']

        if (graphVariant == null) {
            return ImmutableSet.of();
        }

        // Next, return all artifact variants for the selected graph variant.
        return getArtifactsForGraphVariant(graphVariant);
    }

    /**
     * Resolve all artifact variants for the given graph variant.
     */

        when:
        def gradleBuild = getModelWithProjectConnection(rootMulti, GradleBuild)

        then:
        gradleBuild.buildIdentifier.rootDir == rootMulti
    }

    def "ProjectConnection provides all GradleProjects for root of single project build"() {
        when:
        def gradleProjects = getGradleProjectsWithProjectConnectionUsingBuildModel(rootSingle, modelType)

        then:
        gradleProjects.size() == 1

    performanceTestRuntimeOnly(project(":core-api"))
    performanceTestRuntimeOnly(libs.jetty)

    performanceTestDistributionRuntimeOnly(project(":distributions-full")) {
        because("All Gradle features have to be available.")
    }
    performanceTestLocalRepository(project(":tooling-api")) {
        because("IDE tests use the Tooling API.")
    }

/**
 * @see ServiceScope
 */
public interface Scope {

    /**
     * These services are reused across builds in the same process.
     *
     * <p>Global services are visible to all other services.</p>
     */
    interface Global extends Scope {}

    /**
     * These services are reused across builds in the same process while the Gradle user home directory remains unchanged.

import java.util.concurrent.Executors;

/**
 * Reads input from this client stdin and forwards it to the daemon. Can either read raw content or read the user's response to some prompt.
 *
 * <p>Uses a single reader thread to perform all operations.
 */
public class DaemonClientInputForwarder implements Stoppable {
    private final ForwardingUserInput forwarder;
    private final GlobalUserInputReceiver userInput;
    private final ExecutorService executor;

    }

    @Rule ConcurrentTestUtil concurrent = new ConcurrentTestUtil()

    def "the registry can be concurrently written to"() {
        when:
        // obtain localhost address ahead of time as the first call in a JVM can take multiple secs in some systems
        def localhost = Inet6Address.getLocalHost()
        def registry = registry("someDir").get(DaemonRegistry)
        5.times { idx ->
            concurrent.start {

 *
 * Implemented as a enum, so it's easier to generate bytecode.
 */
public enum BytecodeInterceptorFilter {
    INSTRUMENTATION_ONLY(EnumSet.of(BytecodeInterceptorType.INSTRUMENTATION)),
    ALL(EnumSet.of(BytecodeInterceptorType.INSTRUMENTATION, BytecodeInterceptorType.BYTECODE_UPGRADE));

    @SuppressWarnings("ImmutableEnumChecker")
    private final EnumSet<BytecodeInterceptorType> instrumentationTypes;

        gradlePluginPortal()
    }
}

plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
}

includeBuild("../build-logic-settings")

// Shared basics for all
include("basics")

// Platform: defines shared dependency versions
include("build-platform")

// Compute the identity/version we are building and related details (like current git commit)
include("module-identity")

 * a report for multiple projects, by setting the value of the
 * <code>projects</code> property. Here's how to generate an HTML
 * dependency report for all the projects of a multi-project build, for example:
 * <pre>
 * htmlDependencyReport {
 *     projects = project.allprojects
 * }
 * </pre>
 * <p>