expect:
        instanceFactory.getSupportedTypes() == ([ModelType.of(ManagedThingSpec)] as Set)
    }

    def "can register implementation"() {
        instanceFactory.registerFactory(DefaultThingSpec, factoryMock)
        instanceFactory.register(ModelType.of(ThingSpec), new SimpleModelRuleDescriptor("thing"))
            .withImplementation(ModelType.of(DefaultThingSpec))

        when:

        return instantiator.create(name, type);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
        registry.registerFactory(type, factory, descriptor);
    }

    @Override
    public Set<? extends Class<? extends T>> getCreatableTypes() {

        super(ComponentSpec.class);
        this.projectIdentifier = projectIdentifier;
        registerFactory(DefaultComponentSpec.class, new ImplementationFactory<ComponentSpec, DefaultComponentSpec>() {
            @Override

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory) {
        registerFactory(type, factory, null);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
        checkCanRegister(type, descriptor);
        delegate.registerFactory(type, factory);
    }

        given:
        def mmType = ModelTypes.modelMap(Bean)
        registry
            .registerModelMap("beans", Bean) {
                it.registerFactory(Bean) { new Bean(name: it) }
                it.registerFactory(SpecialBean) { new SpecialBean(name: it) }
            }
            .registerInstance("s", "other")
            .mutate {
                it.path("beans").type(mmType).action { c ->

            super(type, instantiator, namer)
        }

        @Override
        <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
            registerFactory(type, factory)
        }
    }

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

    }

    def "can add and configure publication with API"() {
        given:
        Publication pub = publication("test")
        NamedDomainObjectFactory<Publication> factory = Mock()
        container.registerFactory(Publication, factory)

        when:
        container.create("name", Publication) {
            value = 2
        }

        then:
        1 * factory.create("name") >> pub

        and:

                    return instantiator.newInstance(DefaultNativePlatform.class, name);
                }
            };

            platforms.registerFactory(NativePlatform.class, nativePlatformFactory);

            platforms.registerFactory(Platform.class, nativePlatformFactory);
        }

        @ComponentType
        void registerSharedLibraryBinaryType(TypeBuilder<SharedLibraryBinarySpec> builder) {

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

public interface RuleAwareNamedDomainObjectFactoryRegistry<T> extends NamedDomainObjectFactoryRegistry<T> {

    <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor);

            final WorkerLeaseService workerLeaseService = serviceRegistry.get(WorkerLeaseService.class);

            toolChainRegistry.registerFactory(Clang.class, new NamedDomainObjectFactory<Clang>() {
                @Override
                public Clang create(String name) {