|`RegularFileProperty`
|Configurable regular file location, whose value is mutable

|`DirectoryProperty`
|Configurable directory location, whose value is mutable

|`ListProperty<T>`
|List of elements of type `T`

|`SetProperty<T>`
|Set of elements of type `T`

|`MapProperty<K, V>`
|Map of `K` type keys with `V` type values

|`ConfigurableFileCollection`

        ]
    }

    def "configures runtimeClasspath"() {
        def mutable = AttributeTestUtil.attributesFactory().mutable()
        def attrs = Mock(HasConfigurableAttributes)

        when:
        services.configureAsRuntimeClasspath(attrs)

        then:
        1 * attrs.getAttributes() >> mutable
        0 * _
        mutable.asMap() == [
            (CATEGORY_ATTRIBUTE): named(Category, LIBRARY),

        while (it.hasNext() && !mutable.isEmpty()) {
            String name = it.next().getName();
            mutable.applicationClasspath.removeIf(module -> module.getJarFilePattern().matcher(name).matches());
            mutable.applicationModulepath.removeIf(module -> module.getJarFilePattern().matcher(name).matches());

                @Override
                protected ScalarCollectionModelView<E, List<E>> toView(MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor, boolean mutable) {
                    return new ListModelView<E>(modelNode.getPath(), elementType, modelNode, ruleDescriptor, readOnly, mutable);
                }
            };
        }

            def mutable = new DefaultMutableVersionConstraint("")
            spec.delegate = mutable
            spec.resolveStrategy = Closure.DELEGATE_FIRST
            spec.call()
            def version = DefaultImmutableVersionConstraint.of(mutable)
            assert model.version == version
        }
    }

    @CompileStatic

  opts.gen_program_shape = true;
  tf2xla::Config config;
  tf2xla::Feed* feed = config.add_feed();
  feed->mutable_id()->set_node_name("feed0");
  feed->set_name("myfeed");
  feed = config.add_feed();
  feed->mutable_id()->set_node_name("feed1");
  tf2xla::Fetch* fetch = config.add_fetch();
  fetch->mutable_id()->set_node_name("fetch0");
  fetch->set_name("myfetch");
  tf2xla::Variable* variable = config.add_variable();

		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)

				mutable := &MutableGatewayListener{}
				mutableopts[lname] = mutableListenerOpts{mutable: mutable, opts: opts, transport: transport}
			} else {
				mopts.opts.filterChainOpts = append(mopts.opts.filterChainOpts, opts.filterChainOpts...)
			}
		}
	}
	listeners := make([]*listener.Listener, 0)
	for _, ml := range mutableopts {
		ml.mutable.Listener = buildGatewayListener(*ml.opts, ml.transport)

            modelView = getAdapter().asImmutable(type, this, ruleDescriptor);
        }
        if (modelView == null) {
            throw new IllegalStateException("Model element " + getPath() + " cannot be expressed as a mutable view of type " + type);
        }
        return modelView;
    }

    @Override
    public <T> T getPrivateData(Class<T> type) {
        return getPrivateData(ModelType.of(type));
    }

    @Override

    private boolean externalVariant;
    private boolean isComponentMetadataRuleCachingEnabled;
    private List<String> statusScheme = DEFAULT_STATUS_SCHEME;
    private MutableModuleSources moduleSources;
    private /*Mutable*/AttributeContainerInternal componentLevelAttributes;
    private final AttributesSchemaInternal schema;

    private final VariantMetadataRules variantMetadataRules;