assertBitEquals(expectedMax, a.get());
      }
    }
  }

  /** getAndUpdate with sum stores sum of given value to current, and returns previous value */
  public void testGetAndUpdateWithSum() {
    for (double x : VALUES) {
      for (double y : VALUES) {
        AtomicDouble a = new AtomicDouble(x);
        double z = a.getAndUpdate(value -> value + y);
        assertBitEquals(x, z);

        }
      }
    }
  }

  /** getAndUpdate adds given value to current, and returns previous value */
  public void testGetAndUpdateWithSum() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      for (double x : VALUES) {
        for (double y : VALUES) {
          aa.set(i, x);
          double z = aa.getAndUpdate(i, value -> value + y);
          assertBitEquals(x, z);

    return getAndUpdate(key, oldValue -> accumulatorFunction.applyAsLong(oldValue, x));
  }

  /**
   * Associates {@code newValue} with {@code key} in this map, and returns the value previously
   * associated with {@code key}, or zero if there was no such value.
   */
  @CanIgnoreReturnValue
  public long put(K key, long newValue) {
    return getAndUpdate(key, x -> newValue);
  }

  /**

   * @since 31.1
   */
  @CanIgnoreReturnValue
  public final double getAndAccumulate(int i, double x, DoubleBinaryOperator accumulatorFunction) {
    checkNotNull(accumulatorFunction);
    return getAndUpdate(i, oldValue -> accumulatorFunction.applyAsDouble(oldValue, x));
  }

  /**
   * Atomically updates the element at index {@code i} with the results of applying the given
   * function to the current and given values.