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) {

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

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

        def backingCollection = new DefaultDomainObjectSet(SomeType, CollectionCallbackActionDecorator.NOOP)
        def instantiator = new DefaultPolymorphicNamedEntityInstantiator(SomeType, "the collection")
        instantiator.registerFactory(SomeType, new NamedDomainObjectFactory<SomeType>(){
            SomeType create(String name) {
                return new SomeType(name: name)
            }
        })

            names.add(clazz.getSimpleName());
        }
        Collections.sort(names);
        return names.isEmpty() ? "(None)" : Joiner.on(", ").join(names);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory) {
        if (!baseType.isAssignableFrom(type)) {

            final SystemLibraryDiscovery standardLibraryDiscovery = serviceRegistry.get(SystemLibraryDiscovery.class);

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

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

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

        parent.add(type("typeTwo"))
        parent.add(subtype("subTypeOne"))
        parent.add(subtype("subTypeTwo"))
        parent.add(otherSubtype("otherSubType"))

        parent.registerFactory(CreatedSubType, { String name ->
            return new DefaultCreatedSubType(name)
        })
    }

    def "test returns subtype elements"() {
        when:

    def factory = Mock(NamedDomainObjectFactory)
    def platform = new DefaultNativePlatform("platform")

    def "setup"() {
        project.extensions.add("toolChains", registry)
        registry.registerFactory(TestNativeToolChain, factory)
    }

    def "adds default tool chains"() {
        def defaultToolChain1 = unavailableToolChain("test1")
        def defaultToolChain2 = availableToolChain("test2")