return node1;
    }

    private Map<String, MojoExecution> mergeMojos(Map<String, MojoExecution> l1, Map<String, MojoExecution> l2) {
        l2.forEach(l1::putIfAbsent);
        return l1;
    }

    // gather artifactIds which are not unique so that the respective thread names can be extended with the groupId
    public Set<String> duplicateIds() {

        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertThat(cache.asMap().putIfAbsent(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        Object newKey = new Object();
        assertThat(cache.asMap().putIfAbsent(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below

   * zero, associate it with {@code newValue}. Returns the previous value associated with {@code
   * key}, or zero if there was no mapping for {@code key}.
   */
  long putIfAbsent(K key, long newValue) {
    AtomicBoolean noValue = new AtomicBoolean(false);
    Long result =
        map.compute(
            key,
            (K k, @Nullable Long oldValue) -> {

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            throw uoe();
        }

        @Override
        public V putIfAbsent(K key, V value) {
            throw uoe();
        }

        @Override
        public boolean remove(Object key, Object value) {
            throw uoe();
        }

        @Override

        if (desc == null) {
            synchronized (key) {
                desc = descriptors.get(key);
                if (desc == null) {
                    desc = supplier.load();
                    descriptors.putIfAbsent(key, clone(desc));
                }
            }
        }
        return clone(desc);
    }

    @Override
    public void put(Key cacheKey, PluginDescriptor pluginDescriptor) {

    }

    private final ConcurrentHashMap<TransferResourceIdentifier, Boolean> ongoing = new ConcurrentHashMap<>();

    @Override
    public void transferInitiated(TransferEvent event) {
        ongoing.putIfAbsent(new TransferResourceIdentifier(event.getResource()), Boolean.TRUE);
        put(event, false);
    }

    @Override
    public void transferStarted(TransferEvent event) throws TransferCancelledException {

        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertThat(cache.asMap().putIfAbsent(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        Object newKey = new Object();
        assertThat(cache.asMap().putIfAbsent(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below

            E result = (E) canonical;
            return result;
          }
        }

        // didn't see it, trying to put it instead...
        Dummy sneaky = map.putIfAbsent(sample, Dummy.VALUE);
        if (sneaky == null) {
          return sample;
        } else {
          /* Someone beat us to it! Trying again...
           *

      }
    }
  }

  public void fetch(HttpUrl url) throws IOException {
    // Skip hosts that we've visited many times.
    AtomicInteger hostnameCount = new AtomicInteger();
    AtomicInteger previous = hostnames.putIfAbsent(url.host(), hostnameCount);
    if (previous != null) hostnameCount = previous;
    if (hostnameCount.getAndIncrement() >= hostLimit) return;

    Request request = new Request.Builder()
        .url(url)

    }

    private final ConcurrentHashMap<TransferResourceIdentifier, Boolean> ongoing = new ConcurrentHashMap<>();

    @Override
    public void transferInitiated(TransferEvent event) {
        ongoing.putIfAbsent(new TransferResourceIdentifier(event.getResource()), Boolean.TRUE);
        put(event, false);
    }

    @Override
    public void transferStarted(TransferEvent event) throws TransferCancelledException {