* Returns the component types, in display order.
     */
    public List<ComponentType> getComponentTypes() {
        return Arrays.asList(ComponentType.values());
    }

    /**
     * Returns the default component type to use for interactive initialization.
     */
    public ComponentType getDefaultComponentType() {
        return ComponentType.APPLICATION;
    }

    // This should turn into a set of converters at some point

            """.stripIndent().trim()
    }

    def "components report for #componentType / #binaryType / #sourceType show all software components"() {
        given:
        buildFile << """
            ${registerAllTypes()}
            ${declareSoftwareComponents(componentType, binaryType, sourceType)}
        """.stripIndent()

        when:
        succeeds 'components'

          }
        }
        return subtypeOf(componentType);
      }
    }
    return null;
  }

  private static final class GenericArrayTypeImpl implements GenericArrayType, Serializable {

    private final Type componentType;

    GenericArrayTypeImpl(Type componentType) {
      this.componentType = JavaVersion.CURRENT.usedInGenericType(componentType);
    }

    @Override

          }
        }
        return subtypeOf(componentType);
      }
    }
    return null;
  }

  private static final class GenericArrayTypeImpl implements GenericArrayType, Serializable {

    private final Type componentType;

    GenericArrayTypeImpl(Type componentType) {
      this.componentType = JavaVersion.CURRENT.usedInGenericType(componentType);
    }

    @Override

        buildFile << """
            class RegisterComponentInternalViewRules extends RuleSource {
                @ComponentType
                void registerUnmanaged(TypeBuilder<UnmanagedComponentSpec> builder) {
                    builder.internalView(UnmanagedComponentSpecInternal)
                }

                @ComponentType
                void registerManaged(TypeBuilder<ManagedComponentSpec> builder) {

// end::text-tasks-generation[]
    @ComponentType
    void registerComponent(TypeBuilder<DocumentationComponent> builder) {}
// end::component-registration[]

// tag::binary-registration[]
    @ComponentType
    void registerBinary(TypeBuilder<DocumentationBinary> builder) {}
// end::binary-registration[]

// tag::text-lang-registration[]
    @ComponentType
    void registerText(TypeBuilder<TextSourceSet> builder) {}

    }

    def "componentType is null on non-array types"() {
        expect:
        typeOf(String).componentType == null
        new TypeOf<List<String>>() {}.componentType == null
        new TypeOf<List<?>>() {}.actualTypeArguments[0].with { wildcard && componentType == null }
    }

    def "getFullyQualifiedName returns FQN"() {
        given:

                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }

                @Mutate
                void createSampleBinaryInstances(BinaryContainer binaries) {
                    binaries.create("sampleBinary", SampleBinary)
                }

                @ComponentType

        interface NonRegisteredComponent extends SampleComponent {}

        class Rules extends RuleSource {
            @ComponentType
            void register1(TypeBuilder<SampleComponent> builder) {}
            @ComponentType
            void register2(TypeBuilder<Sample2Component> builder) {}
            @Model
            void things(ModelMap<SampleComponent> m) {}
        }

        void apply(final Project project) {}

        static class ComponentModel extends RuleSource {
            @ComponentType
            void registerLibrary(TypeBuilder<SampleLibrary> builder) {}

            @ComponentType
            void registerBinary(TypeBuilder<SampleBinary> builder) {}

            @ComponentType
            void registerSourceSet(TypeBuilder<LibrarySourceSet> builder) {
            }
        }
    }