}

  @CanIgnoreReturnValue
  @Override
  @SuppressWarnings("nullness") // https://github.com/jspecify/jdk/issues/118
  public boolean replace(K key, V oldValue, V newValue) {
    return delegate().replace(key, oldValue, newValue);
  }

    // different value
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(1, segment.count);
    assertThat(segment.get(key, hash)).isEqualTo(newValue);

    // cleared
    segment.setWeakValueReferenceForTesting(entry, oldValueRef);
    oldValueRef.clear();
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(0, segment.count);

    // different value
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(1, segment.count);
    assertThat(segment.get(key, hash)).isEqualTo(newValue);

    // cleared
    segment.setWeakValueReferenceForTesting(entry, oldValueRef);
    oldValueRef.clear();
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(0, segment.count);

     *
     * @param oldValue the value that has to match and will be replaced
     * @param newValue the value used in the replacement
     */
    public void replaceIsTrue(String oldValue, Object newValue) {
        transformations.add(new ReplaceIsTrue(oldValue, MAPPER.convertValue(newValue, TextNode.class)));
    }

    /**
     * Replaces all the values of a is_false assertion for all project REST tests.

        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertThat(cache.asMap().put(entry.getKey(), newValue)).isSameInstanceAs(entry.getValue());
        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertThat(cache.asMap().put(newKey, entry.getValue())).isNull();

    value += delta;
  }

  public int addAndGet(int delta) {
    return value += delta;
  }

  public void set(int newValue) {
    value = newValue;
  }

  public int getAndSet(int newValue) {
    int result = value;
    value = newValue;
    return result;
  }

  @Override
  public int hashCode() {
    return value;
  }

  @Override

        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

        assertNull(docMap.put("newKey", "newValue"));
        assertEquals("newValue", docMap.get("newKey"));

        assertEquals("newValue", docMap.put("newKey", "updatedValue"));
        assertEquals("updatedValue", docMap.get("newKey"));

        assertNull(docMap.get("nonexistent"));
    }

    @Test

      }

      while (true) {
        int oldValue = existingCounter.get();
        if (oldValue != 0) {
          try {
            int newValue = Math.addExact(oldValue, occurrences);
            if (existingCounter.compareAndSet(oldValue, newValue)) {
              // newValue can't == 0, so no need to check & remove
              return oldValue;
            }
          } catch (ArithmeticException overflow) {

  private static void putThread(Waiter waiter, Thread newValue) {
    ATOMIC_HELPER.putThread(waiter, newValue);
  }

  /** Non-volatile write of the waiter to the {@link Waiter#next} field. */
  private static void putNext(Waiter waiter, @Nullable Waiter newValue) {
    ATOMIC_HELPER.putNext(waiter, newValue);
  }

  /**

   * iterator tests.
   *
   * @return the new container instance
   * @param newValue the new container instance
   */
  @CanIgnoreReturnValue
  protected C resetContainer(C newValue) {
    container = newValue;
    return container;
  }

  /**
   * @see #expectContents(java.util.Collection)
   * @param elements expected contents of {@link #container}