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

  /** accumulateAndGet with sum adds given value to current, and returns current value */
  public void testAccumulateAndGetWithSum() {
    for (double x : VALUES) {
      for (double y : VALUES) {
        AtomicDouble a = new AtomicDouble(x);
        double z = a.accumulateAndGet(y, Double::sum);
        assertBitEquals(x + y, z);

      }
    }
  }

  /** accumulateAndGet with sum adds given value to current, and returns current value */
  public void testAccumulateAndGetWithSum() {
    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.accumulateAndGet(i, y, Double::sum);

   *
   * @param delta the value to add
   * @return the updated value
   */
  @CanIgnoreReturnValue
  public final double addAndGet(double delta) {
    return accumulateAndGet(delta, Double::sum);
  }

  /**
   * Atomically updates the current value with the results of applying the given function to the
   * current and given values.
   *
   * @param x the update value

   *
   * @param i the index
   * @param delta the value to add
   * @return the updated value
   */
  @CanIgnoreReturnValue
  public double addAndGet(int i, double delta) {
    return accumulateAndGet(i, delta, Double::sum);
  }

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

  /**
   * Adds {@code delta} to the value currently associated with {@code key}, and returns the new
   * value.
   */
  @CanIgnoreReturnValue
  public long addAndGet(K key, long delta) {
    return accumulateAndGet(key, delta, Long::sum);
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the old value.
   */
  @CanIgnoreReturnValue
  public long getAndIncrement(K key) {