}{
		{
			available:               sets.New[string]("dev1", "dev2"),
			fromAffinityExpected:    sets.New[string]("dev2"),
			notFromAffinityExpected: sets.New[string]("dev1"),
			withoutTopologyExpected: sets.New[string](),
		},
		{
			available:               sets.New[string]("dev1", "dev2", "dev3", "dev4"),
			fromAffinityExpected:    sets.New[string]("dev2", "dev3", "dev4"),
			notFromAffinityExpected: sets.New[string]("dev1"),

def OperandsBroadcastToOutputType : Constraint<CPred<
  "TFL::OperandsBroadcastToOutputType($0.getType(), $1.getType(), "
                                     "$2.getType())">>;

def IsTailOfShape : Constraint<CPred<
  "TFL::IsTailOfShape($0.getType(), $1.getType())">>;

def IsReducedTailOfShape : Constraint<CPred<
  "TFL::IsReducedTailOfShape($0.getType(), $1.getType())">>;

        mavenRepo.module("org.utils", "dep2", '2.0').publish()
        createDirs("impl", "dep1", "dep2")
        settingsFile << 'include "impl", "dep1", "dep2"'

        buildFile << """
            $common

            project(":dep1") {
                group "org.utils"
                version = '1.6'
            }

            project(":dep2") {
                group "org.utils"

        metadata.dependencies.size() == 3

        def dep1 = metadata.dependencies[0]
        dep1.selector == moduleId('group-two', 'artifact-one', '11')
        dep1.scope == MavenScope.Compile

        def dep2 = metadata.dependencies[1]
        dep2.selector == moduleId('group-two', 'artifact-three', '11')
        dep2.scope == MavenScope.Compile

        def inheritedDep = metadata.dependencies[2]

  - dep (created by: dep creator)
  - dep2 (created by: dep2 creator)""")
    }

    def "can apply RuleSource to node"() {
        when:
        registry.registerInstance("bean", new Bean())
        registry.configure(ModelActionRole.Create) { it.path("bean").node { node -> node.applyToSelf(BeanRules) } }

        then:
        def bean = registry.realize("bean", Bean)
        bean.name == 'bean'

			}
			ident := idents[test.name][0]
			def := info.Defs[ident]
			if def == test.obj {
				t.Fatalf("info.Defs[%s] contains the test object", test.name)
			}
			if orig := originObject(test.obj); def != orig {
				t.Errorf("info.Defs[%s] does not match obj.Origin()", test.name)
			}
			if def.Pkg() != test.obj.Pkg() {
				t.Errorf("Pkg() = %v, want %v", def.Pkg(), test.obj.Pkg())
			}

    def "can set untyped using provider"() {
        def provider = supplierWithValues(someValue(), someValue())

        given:
        def property = propertyWithNoValue()
        property.setFromAnyValue(provider)

        expect:
        property.present
        property.get() == someValue()
    }

    def "convention value is used before value has been set"() {
        def property = propertyWithNoValue()

    }

    def "build dependencies are calculated from the artifacts visited during graph resolution"() {
        def configuration = conf()
        def targetTask = Mock(Task)
        def task1 = Mock(Task)
        def task2 = Mock(Task)
        def requiredTasks = [task1, task2] as Set
        def artifactTaskDependencies = Mock(TaskDependency)
        def visitedArtifactSet = Mock(VisitedArtifactSet)

        when:
        def result = registry.get(BigDecimal)

        then:
        result == value

        and:
        1 * parent.get(BigDecimal) >> value
    }

    def delegatesToParentsForUnknownService() {
        def value = BigDecimal.TEN
        def parent1 = Mock(ParentServices)
        def parent2 = Mock(ParentServices)

        then:
        _ * provider2.elementType >> type
        0 * _
    }

    def "can execute action to configure element when element is realized"() {
        containerAllowsExternalProviders()
        def action = Mock(Action)
        def provider1 = Mock(ProviderInternal)
        def provider2 = Mock(ProviderInternal)
        def provider3 = Mock(CollectionProviderInternal)

        given: