*
     * @return the components.
     */
    @Console
    public List<String> getComponents() {
        return components;
    }

    /**
     * Sets the components to generate the report for.
     *
     * @param components the components.
     */
    @Option(option = "component", description = "Component to generate the report for (can be specified more than once).")

            writeComponentReference(component, requireAllVariants, encoder);
        }
    }

    private void writeComponentReference(ComponentGraphResolveState component, boolean requireAllVariants, Encoder encoder) throws IOException {
        encoder.writeBoolean(false);
        long instanceId = component.getInstanceId();
        components.putIfAbsent(instanceId, component);
        encoder.writeSmallLong(instanceId);

import org.gradle.internal.component.model.IvyArtifactName;

final class DefaultExcludeAllOf extends DefaultCompositeExclude implements ExcludeAllOf {
    public static ExcludeAllOf of(ImmutableSet<ExcludeSpec> components) {
        return new DefaultExcludeAllOf(components);
    }

    private DefaultExcludeAllOf(ImmutableSet<ExcludeSpec> components) {
        super(components);
    }

    @Override
    int mask() {

        }
    }
}
'''

        expect:
        succeeds "verify"
    }

    def "source sets can be added to the binaries of a component using a rule applied to all components"() {
        given:
        buildFile << '''
model {
    components {
        all {
            binaries {
                all {
                    sources {
                        custom(CustomLanguageSourceSet)

 */

package org.jetbrains.kotlin.analysis.api.platform

/**
 * A **platform component** as defined by the Platform Interface (see the README).
 *
 * Mandatory platform components must be implemented by a platform to fully support the Analysis API in the desired environment. A few
 * platform components are optional, signified by [KotlinOptionalPlatformComponent]. As a marker interface, [KotlinPlatformComponent]

package org.gradle.integtests.resolve.rules

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Tests component metadata rules for external components without metadata.
 */
class ComponentMetadataRulesMissingMetadataIntegrationTest extends AbstractIntegrationSpec {

    def "rule can define dependencies for component without metadata in Groovy DSL"() {
        given:
        mavenRepo.module("org", "foo").withNoPom().publish()

	</component>

	<component name="ftpClient"
		class="org.codelibs.fess.crawler.client.ftp.FtpClient" instance="prototype">
		<property name="charset">"UTF-8"</property>
	</component>

	<component name="storageClient"
		class="org.codelibs.fess.crawler.client.storage.StorageClient" instance="prototype">
		<property name="charset">"UTF-8"</property>
	</component>

	<component name="crawlerClientCreator"

        ${toolChain.buildScriptConfig}
    }
    components {
        someExe(NativeExecutableSpec)
    }
    testSuites {
        someExeTest(CUnitTestSuiteSpec)
    }
}
"""
        when:
        fails "components"

        then:
        failure.assertHasCause "Test suite 'someExeTest' doesn't declare component under test. Please specify it with `testing \$.components.myComponent`."
    }

of Pilot replicas is a component setting, because it refers to a component which is a Deployment in the
cluster. Most K8s platform settings are necessarily component settings.
The available features and the components that comprise each feature are as follows:

| Feature | Components |
|---------|------------|
CRDs, and other cluster wide configs | Base
Traffic Management | Pilot
Security | Pilot

    }

    def "library has name, path and sensible display name"() {
        when:
        def component = create(SampleComponent, MySampleComponent)

        then:
        component instanceof SampleComponent
        component.name == componentId.name
        component.projectPath == componentId.projectPath
        component.displayName == "SampleComponent '$componentId.name'"