buildOperations.none(RealizeTaskBuildOperationType, not(withPath(':', ':foo')))
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, subprojects")
    def "registration and realization ops have correct paths"() {
        given:
        def createTasks = {
            buildFile << """
                apply plugin: 'base'

    private void defineTaskInSettings(TestFile settingsFile) {
        settingsFile << """
            gradle.rootProject {
                allprojects {
                    task thing {
                        def registry = project.services.get(${BuildStateRegistry.name})
                        doLast {
                            def projects = []

class ResolvedArtifactOrderingIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def setup() {
        settingsFile << """
            rootProject.name = 'root'
"""
        buildFile << """
            allprojects {
                repositories {
                    maven { url '$mavenRepo.uri' }
                }
                configurations {
                    common

        }

        and:
        final dllProject = projectFile("lib/libDll.vcxproj")
        dllProject.assertHasComponentSources(app.library, "src/main")
        dllProject.projectConfigurations.keySet() == projectConfigurations
        dllProject.projectConfigurations.values().each {
            assert it.includePath == filePath("src/main/public", "src/main/headers")

            rootProjectActions.add(decorate(registrationPoint, action));
        }
    }

    @Override
    public void allprojects(final Action<? super Project> action) {
        rootProject("Gradle.allprojects", project -> project.allprojects(action));
    }

    @Override
    public ProjectInternal getDefaultProject() {
        if (defaultProject == null) {

        settingsFile << """
            rootProject.name = 'root'
            include 'a'
        """.stripIndent()
        buildFile << """
            allprojects {
                apply plugin:'java'
            }
            repositories {
               maven { url '${mavenHttpRepo.uri}' }
            }

            dependencies {

    def "includes transitive implementation dependencies in distribution"() {
        given:
        mavenRepo.module('org.gradle.test', 'implementation', '1.0').publish()
        buildFile << """
            allprojects {
                repositories {
                    maven { url '$mavenRepo.uri' }
                }
            }
        """
        createDirs("utils", "core")

        // group name is included in the capabilities of components, which are part of the transform identity
        buildFile << """
            allprojects {
                apply plugin: 'base'
                group = "colored"
            }
            subprojects {
                tasks.withType(DefaultTask) {
                    if (name != "collectScopeIds") {

    def "resolved configurations are exposed via build operation"() {
        setup:
        buildFile << """
            allprojects {
                apply plugin: "java"
                repositories {
                    maven { url '${mavenHttpRepo.uri}' }
                }
            }
            dependencies {

            "include 'sub'",
            "project(':sub').projectDir = new File(settingsDir, 'root/sub')"
        );

        getTestDirectory().createDir("root").file("build.gradle").writelns("allprojects { task thing }");

        inTestDirectory().withTasks(":thing").run().assertTasksExecuted(":thing");
        inTestDirectory().withTasks(":sub:thing").run().assertTasksExecuted(":sub:thing");
    }

    @Test