@Override
    public void increment() {
      getAndIncrement();
    }

    @Override
    public void add(long x) {
      getAndAdd(x);
    }

    @Override
    public long sum() {
      return get();
    }
  }

    @Override
    public void increment() {
      getAndIncrement();
    }

    @Override
    public void add(long x) {
      getAndAdd(x);
    }

    @Override
    public long sum() {
      return get();
    }
  }

  private LongAddables() {}

  public FakeTicker setAutoIncrementStep(Duration autoIncrementStep) {
    return setAutoIncrementStep(autoIncrementStep.toNanos(), NANOSECONDS);
  }

  @Override
  public long read() {
    return nanos.getAndAdd(autoIncrementStepNanos);
  }

   */
  @CanIgnoreReturnValue
  public long getAndIncrement(K key) {
    return getAndAdd(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the old value.
   */
  @CanIgnoreReturnValue
  public long getAndDecrement(K key) {
    return getAndAdd(key, -1);
  }

  /**

        prev = x;
      }
    }
  }

  /** getAndAdd returns previous value and adds given value */
  public void testGetAndAdd() {
    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.getAndAdd(i, y);
          assertBitEquals(x, z);

                      case 4:
                        map.getAndDecrement(key);
                        threadSum--;
                        break;
                      case 5:
                        map.getAndAdd(key, delta);
                        threadSum += delta;
                        break;
                      case 6:
                        long oldValue = map.put(key, delta);

  public FakeTicker setAutoIncrementStep(Duration autoIncrementStep) {
    return setAutoIncrementStep(autoIncrementStep.toNanos(), NANOSECONDS);
  }

  @Override
  public long read() {
    return nanos.getAndAdd(autoIncrementStepNanos);
  }

  }

  /**
   * Atomically adds the given value to the current value.
   *
   * @param delta the value to add
   * @return the previous value
   */
  @CanIgnoreReturnValue
  public final double getAndAdd(double delta) {
    return getAndAccumulate(delta, Double::sum);
  }

  /**
   * Atomically adds the given value to the current value.
   *
   * @param delta the value to add

   *
   * @param i the index
   * @param delta the value to add
   * @return the previous value
   */
  @CanIgnoreReturnValue
  public final double getAndAdd(int i, double delta) {
    return getAndAccumulate(i, delta, Double::sum);
  }

  /**
   * Atomically adds the given value to the element at index {@code i}.
   *
   * @param i the index