// Do more stuff...
        }
}
```

When a component is created, the framework tracks its lifecycle. When the test exits, any components that were
created during the test are automatically closed.

### Writing Components

To add a new component, you'll first need to create a top-level folder for your component under the
[components folder](https://github.com/istio/istio/tree/master/pkg/test/framework/components).

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

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;

--

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

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

			}
			if enabled {
				enabledComponents = append(enabledComponents, string(c))
			}
		}
		for _, c := range iopSpec.Components.IngressGateways {
			if c != nil && c.Enabled.GetValue() {
				enabledComponents = append(enabledComponents, string(name.IngressComponentName))
				break
			}
		}
		for _, c := range iopSpec.Components.EgressGateways {

	</component>
	<component name="themeHelper" class="org.codelibs.fess.helper.ThemeHelper">
	</component>
	<component name="queryStringBuilder" class="org.codelibs.fess.util.QueryStringBuilder" instance="prototype">
	</component>
	<component name="queryParser" class="org.codelibs.fess.query.parser.QueryParser">
	</component>
	<component name="facetInfo" class="org.codelibs.fess.entity.FacetInfo">
	</component>

|<COMPONENT_BG_COLOR>   | component |
endlegend
!enddefinelong

' Elements
' ##################################

!define Component(e_alias, e_label, e_techn) rectangle "==e_label\n//<size:TECHN_FONT_SIZE>[e_techn]</size>//" <<component>> as e_alias
!define Component(e_alias, e_label, e_techn, e_descr) rectangle "==e_label\n//<size:TECHN_FONT_SIZE>[e_techn]</size>//\n\n e_descr" <<component>> as e_alias

' Boundaries

        components.all { component ->
            component.publicData = "Some PUBLIC data"
            component.internalData = "Some INTERNAL data"
        }
    }
// tag::type-registration[]
}
// end::type-registration[]
// end::internal-view-mutation[]

// tag::build-script[]
apply plugin: MyPlugin
model {
    components {
        my(MyComponent)
    }
}