new VersionParser(),
        variantSelector,
        buildOperationProcessor
    )

    def root = rootProject()
    def rootComponent = Stub(RootComponentMetadataBuilder.RootComponentState) {
        getRootComponent() >> root
        getRootVariant() >> root.getConfiguration('root')
    }

    private TestGraphVisitor resolve(Spec<? super DependencyMetadata> edgeFilter = { true }) {

  org:dep2:3.0 -> org:dep2:3.0 - Could not resolve org:dep2:3.0.
"""
    }

    def "visiting resolved module version again has no effect"() {
        def root = rootNode(1, "org", "root", "1.0")
        def selector = selector(7, "org", "dep1", "2.0")
        root.outgoingEdges >> [dep(selector, 1, 2)]

        builder.start(root)

        builder.visitNode(root)

        //does not contain unresolved dep, contains root
        modules == [root, dep1.selected, dep2.selected, dep3.selected] as Set
    }

    def "provides hooks for iterating each module or dependency exactly once"() {
        given:
        //root -> dep1,dep2; dep1 -> dep3
        def dep = newDependency('dep1')
        def dep3 = newDependency('dep3')

        }
        outputContains("configuring root")
        outputContains("creating model with parameter='fetch1' for root project 'root'")
        outputContains("creating model with parameter='fetch2' for root project 'root'")

        and:
        models.keySet() ==~ [":"]
        models.values().every { it.size() == 4 }

        }
        configurationsProvider.findByName('root') >> resolvable()
        configurationsProvider.findByName('conf') >> resolvable()

        def root = builder.toRootComponent('root')
        def variant = root.rootComponent.getConfiguration('conf')

        when:
        builder.validator.validateMutation(mutationType)
        def otherRoot = builder.toRootComponent('root')

        then:

# For this module, the dependency providing package
# example.net/ambiguous/nested/pkg is unambiguous in Go 1.17 (because only one
# root of the module graph contains the package), whereas it is ambiguous in
# Go 1.16 (because two different modules contain plausible packages and Go 1.16
# does not privilege roots above other dependencies).
#
# However, the overall build list is identical for both versions.

cp go.mod go.mod.orig

}

TEST(NodeMatchers, OutputIndices) {
  Scope root = Scope::NewRootScope().ExitOnError();
  Output pred = ops::Placeholder(root.WithOpName("pred"), DT_BOOL);

  Output data = ops::Placeholder(root.WithOpName("data"), DT_FLOAT);
  ops::Switch sw(root.WithOpName("switch"), data, pred);
  Output add = ops::Add(root.WithOpName("add"), sw.output_true,
                        ops::Placeholder(root.WithOpName("addend"), DT_FLOAT));

    }

    def "Eclipse can handle cycles involving the root build"() {
        given:
        compositeWithRootInvolvingIncludeCycle()

        when:
        def eclipseProjects = withConnection { action(new FetchEclipseProjects()).run() }

        then:
        eclipseProjects.collect { it.name } == ['module-root', 'module-a']
    }

                includeBuild 'includedBuild'
            """
        }
        multiProjectBuildInSubFolder("includedBuild", ["a", "b", "c"])
        when:
        GradleBuild model = loadToolingModel(GradleBuild)

        then:
        model.includedBuilds.empty
    }

    def "No included builds for single root project"() {
        singleProjectBuildInRootFolder("root")
        when:

        output.contains('system_property_available in included root:            true')
        output.contains('project_property_available in included root:           false')
        output.contains('overridden_by_includedBuild in included root:          included')
        output.contains('system_property_available in root:                     true')
        output.contains('project_property_available in root:                    true')