}

    def "mapped provider is presented with immutable copy of value"() {
        given:
        property.set(['k1': 'v1'])
        def provider = property.map {
            assertImmutable(it)
            assert it == ['k1': 'v1']
            return ['k2': 'v2']
        }

        when:
        def actual = provider.get()
        then:
        actual == ['k2': 'v2']
    }

    @Override
    public void add(int index, T element) {
        assertMutable("add(int, T)");
        assertCanAdd(element);
        getStore().add(index, element);
        didAdd(element);
        getEventRegister().fireObjectAdded(element);
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        assertMutable("addAll(int, Collection)");
        boolean changed = false;

        assertMutable("resolvable(String)");
        return registerResolvableConfiguration(name, Actions.doNothing());
    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name, Action<? super ResolvableConfiguration> action) {
        assertMutable("resolvableUnlocked(String, Action)");

        assertMutable("addLater(Provider)");
        assertMutableCollectionContents();
        ProviderInternal<? extends T> providerInternal = Providers.internal(provider);
        store.addPending(providerInternal);
    }

    @Override
    public void addAllLater(Provider<? extends Iterable<T>> provider) {
        assertMutable("addAllLater(Provider)");

    }

    @Override
    public <T> AttributeContainer attribute(Attribute<T> key, T value) {
        assertMutable();
        delegate.attribute(key, value);
        return this;
    }

    @Override
    public <T> AttributeContainer attributeProvider(Attribute<T> key, Provider<? extends T> provider) {
        assertMutable();
        delegate.attributeProvider(key, provider);
        return this;
    }

    @Nullable

    }

    @Override
    public void setFrom(Iterable<?> path) {
        assertMutable();
        setExplicitCollector(newExplicitValue(path));
    }

    @Override
    public ConfigurableFileCollection convention(Iterable<?> paths) {
        assertMutable();
        setConventionCollector(newConventionValue(paths));
        return this;
    }

    @Override

    }

    @Override
    public T create(String name, Closure configureClosure) {
        assertMutable("create(String, Closure)");
        return create(name, ConfigureUtil.configureUsing(configureClosure));
    }

    @Override
    public T create(String name, Action<? super T> configureAction) throws InvalidUserDataException {
        assertMutable("create(String, Action)");
        assertCanAdd(name);
        T object = doCreate(name);

        assertMutable("create(Map<String, ?>, Closure)");
        return doCreate(options, ConfigureUtil.configureUsing(configureClosure));
    }

    @Override
    public <T extends Task> T create(String name, Class<T> type) {
        assertMutable("create(String, Class)");
        return doCreate(name, type, NO_ARGS, Actions.doNothing());
    }

        assertMutable("register(String, Class)");
        return createDomainObjectProvider(name, type, null);
    }

    @Override
    public <U extends T> NamedDomainObjectProvider<U> register(String name, Class<U> type, Action<? super U> configurationAction) throws InvalidUserDataException {
        assertMutable("register(String, Class, Action)");

            return repository.getName();
        }
    }

    @Override
    public void repository(String name, Action<? super JavaToolchainRepository> configureAction) {
        assertMutable();

        DefaultAuthenticationContainer authenticationContainer = new DefaultAuthenticationContainer(instantiator, CollectionCallbackActionDecorator.NOOP);