def barReference = ModelReference.of("bar", List)

        def descriptor = new SimpleModelRuleDescriptor("foo")

        def fooList = []
        def fooRegistration = ModelRegistrations.bridgedInstance(fooReference, fooList).descriptor(descriptor).build()
        registry.register(fooRegistration)

        def barList = []
        def factory = Mock(org.gradle.internal.Factory) {
            create() >> barList

    def modelDsl

    def setup() {
        modelDsl = new NonTransformedModelDslBacking(getRegistry())
    }

    void register(String pathString, Object element) {
        registry.register(ModelRegistrations.bridgedInstance(ModelReference.of(pathString, element.class), element).descriptor("register").build())
    }

    def "can add rules via dsl"() {
        given:
        register("foo", [])

        when:

@ThreadSafe
public abstract class ModelRegistrations {

    public static <T> Builder serviceInstance(ModelReference<T> modelReference, T instance) {
        return bridgedInstance(modelReference, instance)
            .hidden(true);
    }

    public static <T> Builder bridgedInstance(ModelReference<T> modelReference, T instance) {
        return unmanagedInstance(modelReference, Factories.constant(instance), Actions.doNothing());
    }

        }
    }

    Class<NamedThing> itemClass = NamedThing
    Class<SpecialNamedThing> specialItemClass = SpecialNamedThing

    def setup() {
        registry.register(
            ModelRegistrations.bridgedInstance(
                ModelReference.of(path, new ModelType<NamedEntityInstantiator<NamedThing>>() {}),
                { name, type -> DirectInstantiator.instantiate(type, name) } as NamedEntityInstantiator
            )