when:
        project.components.add(component)

        then:
        project.components.size() == 1

        when:
        binaries.add(b1)
        binaries.add(b2)
        binaries.realizeNow()

        then:
        project.components.size() == 3
        project.components.b1 == b1
        project.components.b2 == b2
    }

    def "assemble task does nothing when no main component"() {

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN"
	"http://dbflute.org/meta/lastadi10.dtd">
<components>
	<component name="dataStoreFactory" class="org.codelibs.fess.ds.DataStoreFactory">
	</component>
	<component name="indexUpdateCallback" class="org.codelibs.fess.ds.callback.IndexUpdateCallbackImpl" instance="prototype">
	</component>

<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN"
	"http://dbflute.org/meta/lastadi10.dtd">
<components>
	<component name="rankFusionProcessor"
		class="org.codelibs.fess.rank.fusion.RankFusionProcessor">
		<postConstruct name="setSeacher">
			<arg>
				<component
					class="org.codelibs.fess.rank.fusion.DefaultSearcher">
				</component>
			</arg>
		</postConstruct>
	</component>

		return true
	}
	if len(i.components) != len(components) {
		return false
	}
	for c := 0; c < len(i.components); c++ {
		if i.components[c].ComponentName() != components[c].ComponentName() {
			return false
		}
		if i.components[c].Namespace() != components[c].Namespace() {
			return false
		}
		if i.components[c].Enabled() != components[c].Enabled() {
			return false
		}

import org.gradle.internal.component.model.AttributeMatcher;
import org.gradle.internal.component.model.ComponentGraphResolveMetadata;
import org.gradle.internal.component.model.GraphSelectionCandidates;
import org.gradle.internal.component.model.GraphVariantSelector;
import org.gradle.internal.component.model.VariantGraphResolveState;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN"
	"http://dbflute.org/meta/lastadi10.dtd">
<components namespace="fessCrawler">

	<component class="org.lastaflute.di.naming.StyledNamingConvention">
	</component>

	<!-- Container -->
	<component name="crawlerContainer"
		class="org.codelibs.fess.crawler.container.LastaCrawlerContainer">
	</component>

--

This is an important concept because:

- By default, a variant provides a capability corresponding to the GAV coordinates of its component
- No two variants in a dependency graph can provide the same capability
- Multiple variants of a single component may be selected as long as they provide _different capabilities_

model {
    components {
        custom(ComponentWithValue) {
            valueForBinary = "create-value"
        }
    }
    components {
        custom {
            valueForBinary = "configured-value"
        }
    }
    tasks {
        checkModel(Task) {
            doLast {
                def component = \$.components.custom
                assert component.binaries.size() == 1

    {{< text yaml >}}
    components:
      base:
        enabled: false
      pilot:
        enabled: false
      istiodRemote:
        enabled: true
    values:
      global:
        externalIstiod: true
    {{< /text >}}

    If the remote cluster also serves as the config cluster for the external control plane,
    the `base` component would also be enabled:

    {{< text yaml >}}
    components:
      base:

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

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

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

    @Override
    int mask() {