filtered.put("b", 4);
    assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered);

    Entry<String, Integer> entry = filtered.entrySet().iterator().next();
    assertThrows(IllegalArgumentException.class, () -> entry.setValue(5));

    assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered);
  }

  public void testFilteredValuesClear() {
    Map<String, Integer> unfiltered = createUnfiltered();
    unfiltered.put("one", 1);

    assertThrows(UnsupportedOperationException.class, () -> map.putAll(ImmutableMap.of("b", "2")));

    assertThrows(
        UnsupportedOperationException.class,
        () -> map.entrySet().iterator().next().setValue("one"));
  }

  public void testTransformRemoveEntry() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);

   * Returns a map view that associates each key with the corresponding values in the multimap.
   * Changes to the returned map, such as element removal, will update the underlying multimap. The
   * map does not support {@code setValue()} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same

    assertThrows(UnsupportedOperationException.class, () -> map.putAll(ImmutableMap.of("b", "2")));

    assertThrows(
        UnsupportedOperationException.class,
        () -> map.entrySet().iterator().next().setValue("one"));
  }

  public void testTransformRemoveEntry() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);

  @ParametricNullness
  K getKey(int index) {
    checkElementIndex(index, size);
    return (K) keys[index];
  }

  int getValue(int index) {
    checkElementIndex(index, size);
    return values[index];
  }

  void setValue(int index, int newValue) {
    checkElementIndex(index, size);
    values[index] = newValue;
  }

  Entry<K> getEntry(int index) {

    assertThrows(UnsupportedOperationException.class, () -> map.putAll(ImmutableMap.of("b", "2")));

    assertThrows(
        UnsupportedOperationException.class,
        () -> map.entrySet().iterator().next().setValue("one"));
  }

  public void testTransformRemoveEntry() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);

                        if (interpolated != null && !interpolated.equals(value)) {
                            try {
                                entry.setValue(interpolated);
                            } catch (UnsupportedOperationException ignore) {
                                // nop
                            }
                        }
                    } else if (value.getClass().isArray()) {

    ImmutableMap<String, String> map = ImmutableMap.copyOf(entryList);
    assertThat(map).containsExactly("a", "1", "b", "2").inOrder();
    entryList.get(0).setValue("3");
    assertThat(map).containsExactly("a", "1", "b", "2").inOrder();
  }

  public void testBuilderPutAllEntryList() {
    List<Entry<String, String>> entryList =

        Object o22 = properties.get(KEY1);
        assertEquals(VALUE1, o22);
        for (Map.Entry<String, String> entry : properties.entrySet()) {
            entry.setValue(entry.getValue() + "x");
        }
        Object o21 = properties.get(KEY1);
        assertEquals(VALUE1 + "x", o21);

        baos = new ByteArrayOutputStream();
        properties.save(baos);

        return delegate().getKey();
      }
    }

    @Override
    public V getValue() {
      synchronized (mutex) {
        return delegate().getValue();
      }
    }

    @Override
    public V setValue(V value) {
      synchronized (mutex) {
        return delegate().setValue(value);
      }
    }