// TODO(srbs): It seems like this is used only for performance optimization
  // and not for correctness. The only downside of keeping this 1 seems to be
  // that the gradient accumulation is unbounded and we will never
  // aggressively aggregate accumulated gradients to recover memory.
  // Revisit and fix.
  return 1;
}

    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(MANY_VALUES);
    Stats stats = accumulator.snapshot();
    accumulator.add(999.999); // should do nothing to the snapshot
    return stats;
  }

  private static Stats buildLongManyValuesStatsSnapshot() {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(LONG_MANY_VALUES);

  public void testCountOverflow_doesNotThrow() {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.add(ONE_VALUE);
    for (int power = 1; power < Long.SIZE - 1; power++) {
      accumulator.addAll(accumulator.snapshot());
    }
    // Should overflow without throwing.
    accumulator.addAll(accumulator.snapshot());
    assertThat(accumulator.count()).isLessThan(0L);
  }

  public void testMean() {

    PairedStatsAccumulator accumulator = new PairedStatsAccumulator();
    accumulator.add(ONE_VALUE, OTHER_ONE_VALUE);
    for (int power = 1; power < Long.SIZE - 1; power++) {
      accumulator.addAll(accumulator.snapshot());
    }
    // Should overflow without throwing.
    accumulator.addAll(accumulator.snapshot());
    assertThat(accumulator.count()).isLessThan(0L);
  }

    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(MANY_VALUES);
    Stats stats = accumulator.snapshot();
    accumulator.add(999.999); // should do nothing to the snapshot
    return stats;
  }

  private static Stats buildLongManyValuesStatsSnapshot() {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(LONG_MANY_VALUES);

  public void testCountOverflow_doesNotThrow() {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.add(ONE_VALUE);
    for (int power = 1; power < Long.SIZE - 1; power++) {
      accumulator.addAll(accumulator.snapshot());
    }
    // Should overflow without throwing.
    accumulator.addAll(accumulator.snapshot());
    assertThat(accumulator.count()).isLessThan(0L);
  }

  public void testMean() {

        accumulatorBitCount -= 8
        sink.writeByte((accumulator shr accumulatorBitCount).toInt())
      }
    }

    if (accumulatorBitCount > 0) {
      accumulator = accumulator shl (8 - accumulatorBitCount)
      accumulator = accumulator or (0xffL ushr accumulatorBitCount)
      sink.writeByte(accumulator.toInt())
    }
  }

  fun encodedLength(bytes: ByteString): Int {

    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);
    return accumulator.snapshot();
  }

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values
   */
  public static Stats of(double... values) {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);

    // For datasets of many double values created from an accumulator snapshot, we test many
    // combinations of finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      accumulator.addAll(values.asIterable());
      double min = accumulator.snapshot().min();
      if (values.hasAnyNaN()) {

        // Execute second time - params should be fresh
        Object result2 = scriptExecutor.execute("modifyEngine", "script2");
        assertEquals(2, result2); // Should still be 2, not accumulating
    }

    @Test
    public void test_shutdown_withListener() {
        // Add shutdown listener
        TestShutdownListener listener = new TestShutdownListener();