if (profileProp != null) {
                ActivationProperty prop = new ActivationProperty();

                prop.setName(profileProp.getName());
                prop.setValue(profileProp.getValue());

                activation.setProperty(prop);
            }

            ActivationOS profileOs = profileActivation.getOs();

            if (profileOs != null) {

                "key");
        setupEpg(_epgMap, et -> ((CrawlingInfoParam) et).getValue(), (et, vl) -> ((CrawlingInfoParam) et).setValue(DfTypeUtil.toString(vl)),
                "value");
    }

    @Override
    public PropertyGateway findPropertyGateway(final String prop) {
        return doFindEpg(_epgMap, prop);
    }

    CompactHashMap<Integer, String> map = CompactHashMap.create();
    map.put(1, "1");
    Entry<Integer, String> entry = getOnlyElement(map.entrySet());
    map.remove(1);
    entry.setValue("one");
    assertThat(map).containsEntry(1, "one");
  }

  public void testAllocArraysDefault() {
    CompactHashMap<Integer, String> map = CompactHashMap.create();
    assertThat(map.needsAllocArrays()).isTrue();

      @SuppressWarnings("unchecked")
      Entry<?, @Nullable Object> nullableValueEntry = (Entry<?, @Nullable Object>) entry;
      nullableValueEntry.setValue(null);
      fail("setValue on unmodifiable Map.Entry succeeded");
    } catch (UnsupportedOperationException expected) {
    }
  }

  /**
   * Verifies that an Iterator is unmodifiable.
   *

     *
     * @param target
     *            the target object. Must not be {@literal null}
     * @param value
     *            the value to set to the property
     */
    void setValue(Object target, Object value);

    /**
     * Converts the value to the appropriate type if necessary based on the property type.
     *
     * @param <T>
     *            the converted type

      // Expected.
    }
    assertInvariants(map);
  }

  public void testEntrySetSetValue() {
    // TODO: Investigate the extent to which, in practice, maps that support
    // put() also support Entry.setValue().
    if (!supportsPut) {
      return;
    }

    Map<K, V> map;
    V valueToSet;
    try {
      map = makePopulatedMap();
      valueToSet = getValueNotInPopulatedMap();

      cache.invalidate(1);
      assertThat(cache.size()).isEqualTo(0);

      entry.setValue(3);
      assertThat(cache.size()).isEqualTo(1);
      assertThat(cache.getIfPresent(1)).isEqualTo(3);
      checkValidState(cache);

      assertThrows(NullPointerException.class, () -> entry.setValue(null));
      checkValidState(cache);
    }
  }

  /* ---------------- Local utilities -------------- */

                String org, val;
                // Content
                org = dom.getValue();
                val = interpolate(org);
                if (org != val) {
                    dom.setValue(val);
                }
                // Attributes
                for (String attr : dom.getAttributeNames()) {
                    org = dom.getAttribute(attr);
                    val = interpolate(org);

   * 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

        this.updatedTime = value;
    }

    public String getValue() {
        checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;
    }

    public String getVirtualHost() {
        checkSpecifiedProperty("virtualHost");