/**
 * Declares a custom {@link org.gradle.platform.base.ComponentSpec} type.
 *
 * The following example demonstrates how to register a custom component type using a plugin with a
 * {@link ComponentType} annotation.
 * Furthermore the plugin creates an instance of SampleComponent named 'sampleComponent'.
 *
 * <pre class='autoTested'>
 * interface SampleComponent extends ComponentSpec {}

import java.util.List;

public enum ComponentType {
    // These are in display order
    APPLICATION("Application", "app", "list", "utilities"),
    LIBRARY("Library", "lib"),
    GRADLE_PLUGIN("Gradle plugin", "plugin"),
    BASIC("Basic (build structure only)");

    private final String displayName;
    private final List<String> defaultProjectNames;

    ComponentType(String displayName, String... defaultProjectNames) {

        @ComponentType
        static void extendsType(TypeBuilder<? extends BinarySpec> builder) {
        }

        @ComponentType
        static void superType(TypeBuilder<? super BinarySpec> builder) {
        }

        @ComponentType
        static void notBinarySpec(TypeBuilder<NotBinarySpec> builder) {
        }

        @ComponentType

class GenericArrayTypeWrapper implements TypeWrapper {
    private final TypeWrapper componentType;
    private final int hashCode;

    public GenericArrayTypeWrapper(TypeWrapper componentType, int hashCode) {
        this.componentType = componentType;
        this.hashCode = hashCode;
    }

    public TypeWrapper getComponentType() {
        return componentType;
    }

    @Override
    public Class<?> getRawClass() {

    public ComponentTypeRegistration maybeRegisterComponentType(Class<? extends Component> componentType) {
        ComponentTypeRegistration registration = componentRegistrations.get(componentType);
        if (registration == null) {
            registration = new DefaultComponentTypeRegistration(componentType);
            componentRegistrations.put(componentType, registration);
        }
        return registration;
    }

    @Override

        private final ModelType<C> componentType;
        private final ModelType<S> binaryType;

        public ExtractedComponentBinariesRule(ModelType<C> componentType, ModelType<S> binaryType, MethodRuleDefinition<?, ?> ruleDefinition) {
            super(ruleDefinition);
            this.componentType = componentType;
            this.binaryType = binaryType;
        }

        @Override

    }

    static class Rules {

        @ComponentType
        String returnValue(TypeBuilder<CustomLanguageSourceSet> languageBuilder) {
            return null
        }

        @ComponentType
        void noParams() {
        }

        @ComponentType
        void wrongSubject(LanguageSourceSet sourcet) {
        }

        @ComponentType
        void rawLanguageTypeBuilder(TypeBuilder builder) {

     * 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

// 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: