foo creator
    inputs:
      - <no path> Long [*]
'''
    }

    def "cannot register when by-type input is ambiguous"() {
        given:
        registry.registerInstance("other-1", 11)
        registry.registerInstance("other-2", 12)

        when:
        registry.register("foo") { it.descriptor("foo creator").unmanaged(String, Number, Stub(Transformer)) }
        registry.bindAllReferences()

        String value
    }

    def "by-path bindings of scoped rules are bound to inner scope"() {
        given:
        registry.registerInstance("first", new MutableValue())
            .registerInstance("second", new MutableValue())
            .registerInstance("values", "foo")
            .apply("values", ByPathBoundInputsChildRule)
            .mutate {
            it.path "values" node {

        given:
        ModelRegistryHelper registry = new ModelRegistryHelper()
        ModelPath path = ModelPath.path("tasks")
        registry.registerInstance("tasks", "foo tasks")
            .mutate {
            it.path "tasks" node {
                it.addLinkInstance(taskPath, Mock(realizableType))
            }
        }

        when:

            subject.value = "input: " + input
        }
    }

    def "extracts input parameters"() {
        given:
        registry.registerInstance("input", 12)
        registry.registerInstance("item", new Bean())
        def node = ((DefaultModelRegistry) registry).node("item")

        when:
        def ruleSource = extractor.extract RuleSourceWithParameter

                                                        String name, Closure<I> createUnmanagedInstance) {
        def modelRegistry = new ModelRegistryHelper()
        modelRegistry.registerInstance("nodeInitializerRegistry", ProjectRegistrySpec.NODE_INITIALIZER_REGISTRY)

        def publicTypeSchema = (StructSchema<T>) SCHEMA_STORE.getSchema(publicType)

    def "inputs of a rule from an inner source are not realised if the rule is not required"() {
        given:
        def mmType = ModelTypes.modelMap(Bean)
        def events = []
        registry
            .registerInstance("input", "input") { events << "input created" }
            .registerModelMap("beans", Bean) { it.registerFactory(Bean) { new Bean(name: it) } }
            .mutate {
                it.path "beans" type mmType action { c ->

        set[0].value == "before after"
        set[1].value == "before after"
    }

    def "cannot configure children when used as an input - #method"() {
        when:
        registry.registerInstance("things", []).mutate {
            it.path("things").action(reference.path, reference.type, { things, set ->
                set."$method" {

                }
            })
        }

        return modelRegistry.node(ModelPath.path(path));
    }

    public static <C> ModelRegistry registerInstance(ModelRegistry modelRegistry, String path, final C c) {
        return modelRegistry.register(unmanaged(registration(ModelPath.path(path)), c));
    }

    public static <C> ModelRegistry registerInstance(ModelRegistry modelRegistry, String path, final C c, Action<? super C> action) {