new DefaultSoftwareComponentVariant("test", AttributeTestUtil.attributesFactory().mutable()),
            new DefaultSoftwareComponentVariant("test", AttributeTestUtil.attributesFactory().mutable())
        )
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()

            // most cases. We could create an empty attribute set directly in the AbstractDependencyImpl,
            // but then it wouldn't be mutable. Therefore we proceed with "late injection" of the attributes
            ((AbstractDependencyImpl<?>) dependencyMetadata).setAttributes(attributesFactory.mutable());
        }

        T adapted = adapt(dependencyMetadata);
        if (configureAction != null) {

		connectionPool = &networking.ConnectionPoolSettings{}
	}
	cb.applyConnectionPool(opts.mesh, opts.mutable, connectionPool)
	if opts.direction != model.TrafficDirectionInbound {
		cb.applyH2Upgrade(opts.mutable, opts.port, opts.mesh, connectionPool)
		applyOutlierDetection(opts.mutable.cluster, outlierDetection)
		applyLoadBalancer(opts.mutable.cluster, loadBalancer, opts.port, cb.locality, cb.proxyLabels, opts.mesh)

        this.path = path;
        this.type = type;
        this.elementType = elementType;
        this.modelNode = modelNode;
        this.overwritable = overwritable;
        this.state = new DefaultModelViewState(path, type, descriptor, mutable, false);
    }

    @Override
    public ModelPath getPath() {
        return path;

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

public interface ModelViewFactory<M> {
    ModelView<M> toView(MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor, boolean mutable);

    /**
     * Have the projects been loaded, ie has {@link #ensureProjectsLoaded()} already completed for this build?
     */
    boolean isProjectsLoaded();

    /**
     * Has the mutable model for projects been created yet?
     *
     * @see ProjectState#isCreated()
     */
    boolean isProjectsCreated();

    /**
     * Ensures all projects in this build are configured, if not already done.

    private ImmutableAttributesFactory attributesFactory = AttributeTestUtil.attributesFactory()
    private List<ImmutableAttributes> candidates = []
    private AttributeContainerInternal requested = attributesFactory.mutable()

    private List<Attribute<?>> extraAttributes

    def "collects extra attributes, single candidate"() {
        def attr1 = Attribute.of("foo", String)
        def attr2 = Attribute.of("bar", String)

    a `tf_saved_model.exported_names` attribute.

    The `value` attribute contains the tensor's value (or initial value, in the
    case it is mutable).

    The `type` attribute contains the tensor's type, which for the case of
    mutable tensors might be more general than just the fixed static shape of
    the `value` attribute. For example, a global tensor might be unranked such

    public void preventFromFurtherMutation() {
        this.mutable = false;
        NamedDomainObjectList<ArtifactRepository> repositoryHandler = getRepositories();
        repositoryHandler.whenObjectAdded(this::mutationDisallowed);
        repositoryHandler.whenObjectRemoved(this::mutationDisallowed);
    }

    private void assertMutable() {
        if (!mutable) {

                    String variantName = StringUtils.uncapitalize(String.join("", variantNameToken));

                    AttributeContainer runtimeAttributes = attributesFactory.mutable();
                    runtimeAttributes.attribute(Usage.USAGE_ATTRIBUTE, runtimeUsage);
                    addCommonAttributes(buildType, targetMachine, runtimeAttributes);