assertBitEquals(x - y, a.get());
      }
    }
  }

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

     *
     * @throws IllegalStateException if an id has already been loaded.
     */
    public long createId() {
        long newId = sequence.updateAndGet(it -> it == USED_ASSIGNED_ID_MARKER ? it : it + 1);
        if (newId == USED_ASSIGNED_ID_MARKER) {
            throw new IllegalStateException("Cannot create a new id after one has been loaded");
        }

        }
      }
    }
  }

  /** updateAndGet adds given value to current, and returns current value */
  public void testUpdateAndGetWithSum() {
    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.updateAndGet(i, value -> value + y);

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

  /**
   * Atomically updates the current value with the results of applying the given function.
   *

        if (buildRunning) {
            // TODO Should the loop go on the outside to make updates smaller and less likely to collide, and also cheaper to re-run?
            locationsWrittenByCurrentBuild.updateAndGet(currentValue -> {
                FileHierarchySet newValue = currentValue;
                for (String location : locations) {
                    newValue = newValue.plus(location);
                }

   * @since 31.1
   */
  @CanIgnoreReturnValue
  public final double accumulateAndGet(int i, double x, DoubleBinaryOperator accumulatorFunction) {
    checkNotNull(accumulatorFunction);
    return updateAndGet(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 value.
   *

   * returns the new value. If there is not currently a value associated with {@code key}, the
   * function is applied to {@code 0L}.
   *
   * @since 21.0
   */
  @CanIgnoreReturnValue
  public long updateAndGet(K key, LongUnaryOperator updaterFunction) {
    checkNotNull(updaterFunction);
    Long result =
        map.compute(
            key,