assertThat(cache.asMap().replace(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        assertThat(cache.asMap().replace(entry.getKey(), newValue, entry.getValue())).isTrue();
        Object newKey = new Object();
        assertThat(cache.asMap().replace(newKey, entry.getValue())).isNull();
        assertThat(cache.asMap().replace(newKey, entry.getValue(), newValue)).isFalse();

        assertThat(cache.asMap().replace(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        assertThat(cache.asMap().replace(entry.getKey(), newValue, entry.getValue())).isTrue();
        Object newKey = new Object();
        assertThat(cache.asMap().replace(newKey, entry.getValue())).isNull();
        assertThat(cache.asMap().replace(newKey, entry.getValue(), newValue)).isFalse();

   * the position of the new key if it was previously present.
   */
  private void replaceKeyInEntry(int entry, @ParametricNullness K newKey, boolean force) {
    checkArgument(entry != ABSENT);
    int newKeyHash = Hashing.smearedHash(newKey);
    int newKeyIndex = findEntryByKey(newKey, newKeyHash);

    int newPredecessor = lastInInsertionOrder;
    int newSuccessor = ENDPOINT;
    if (newKeyIndex != ABSENT) {

        StringBuilder newkey = new StringBuilder();

        for (int i = 0; i < key.length(); i++) {
            char c = key.charAt(i);

            if (contains(SEPARATORS, c) || contains(WHITE_SPACE, c)) {
                // escape the separator
                newkey.append('\\');
                newkey.append(c);
            } else {
                newkey.append(c);
            }
        }

        StringBuilder newkey = new StringBuilder();

        for (int i = 0; i < key.length(); i++) {
            char c = key.charAt(i);

            if (contains(SEPARATORS, c) || contains(WHITE_SPACE, c)) {
                // escape the separator
                newkey.append('\\');
                newkey.append(c);
            } else {
                newkey.append(c);
            }
        }

    for (ListIterator<Entry<K, V>> i = expected.listIterator(); i.hasNext(); ) {
      if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
        i.set(newEntry);
        return;
      }
    }

    throw new IllegalArgumentException(
        Platform.format("key %s not found in entries %s", newEntry.getKey(), expected));
  }

  /**

      assertFalse(
          "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed));
      assertFalse(
          "Inverse should not contain key " + reversed.getKey(),
          inv.containsKey(reversed.getKey()));
      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*

   */
  void insertEntry(
      int entryIndex, @ParametricNullness K key, @ParametricNullness V value, int hash, int mask) {
    this.setEntry(entryIndex, CompactHashing.maskCombine(hash, UNSET, mask));
    this.setKey(entryIndex, key);
    this.setValue(entryIndex, value);
  }

  /** Resizes the entries storage if necessary. */
  private void resizeMeMaybe(int newSize) {
    int entriesSize = requireEntries().length;

                writer.accept("\t--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---");

                for (MojoExecution forkedExecution : fork.getValue()) {
                    mojo(writer, forkedExecution);
                }

                writer.accept("\t--- exit fork of " + fork.getKey() + " for " + mojoExecId + " ---");
            }
        }

        Objects.requireNonNull(model, "model cannot be null");

        ClassLoader parent = getMavenApiRealm();

        return createRealm(getKey(model), RealmType.Project, parent, null, null, artifacts);
    }

    private static String getKey(Model model) {
        return "project>" + model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion();
    }

    @Override