for (Object value : values) {
                add(value, dest);
            }
        }
    };

    public static <T> ValueSanitizer<T> forType(Class<? extends T> targetType) {
        if (String.class.equals(targetType)) {
            return Cast.uncheckedCast(STRING_VALUE_SANITIZER);
        } else {
            return Cast.uncheckedCast(IDENTITY_SANITIZER);

import org.gradle.model.internal.fixture.ProjectRegistrySpec
import org.gradle.model.internal.type.ModelType
import org.gradle.util.internal.ClosureBackedAction

import static org.gradle.model.internal.core.NodeInitializerContext.forType

class ModelSetModelProjectionTest extends ProjectRegistrySpec {
    @Managed
    interface NamedThing {
        String getName()

        void setName(String name);

        String getValue()

        this(type, instantiator, instantiator, Named.Namer.forType(type), callbackDecorator);
    }

    public DefaultPolymorphicDomainObjectContainer(Class<T> type, Instantiator instantiator, Instantiator elementInstantiator, CollectionCallbackActionDecorator callbackDecorator) {
        this(type, instantiator, elementInstantiator, Named.Namer.forType(type), callbackDecorator);
    }

    public FactoryNamedDomainObjectContainer(Class<T> type, Instantiator instantiator, NamedDomainObjectFactory<T> factory, CollectionCallbackActionDecorator collectionCallbackActionDecorator) {
        this(type, instantiator, Named.Namer.forType(type), factory, MutationGuards.identity(), collectionCallbackActionDecorator);
    }

    /**
     * <p>Creates a container that instantiates using the given factory.<p>
     *

        @Override
        public String determineName(Named object) {
            return object.getName();
        }

        @SuppressWarnings("unchecked")
        public static <T> org.gradle.api.Namer<? super T> forType(Class<? extends T> type) {
            if (Named.class.isAssignableFrom(type)) {
                return (org.gradle.api.Namer<T>) INSTANCE;
            } else {

import org.gradle.model.internal.manage.schema.StructSchema
import org.gradle.model.internal.type.ModelType
import org.gradle.util.internal.ClosureBackedAction

import static org.gradle.model.internal.core.NodeInitializerContext.forType

abstract class AbstractCollectionModelProjectionTest<T, C extends Collection<T>> extends ProjectRegistrySpec {

    def collectionPath = ModelPath.path("collection")
    def internalType
    def internalTypeSchema

     *
     * @throws UnsupportedOperationException When this selector requires the parameters in order to select a constructor.
     */
    <T> ClassGenerator.GeneratedConstructor<? extends T> forType(Class<T> type) throws UnsupportedOperationException;

    }

    @Override
    public InternalProblems getProblemsService() {
        return ProblemsProgressEventEmitterHolder.get();
    }

    @Override
    public TypeValidationContext forType(Class<?> type, boolean cacheable) {
        types.add(type);
        Supplier<Optional<PluginId>> pluginId = () -> typeOriginInspector.findPluginDefining(type);

        this.modelType = modelType;
        this.constraints = constraints;
        this.propertyContextOptional = propertyContextOptional;
    }

    public static <T> NodeInitializerContext<T> forType(ModelType<T> type) {
        return new NodeInitializerContext<T>(type, Specs.<ModelType<?>>satisfyAll(), Optional.<PropertyContext>absent());
    }

    public DefaultProperty(PropertyHost propertyHost, Class<T> type) {
        super(propertyHost);
        this.type = type;
        this.sanitizer = ValueSanitizers.forType(type);
        init(getDefaultValue());
    }

    @Override
    protected ProviderInternal<? extends T> getDefaultValue() {
        return Providers.notDefined();
    }

    @Override