* java.util.concurrent.atomic} package specification for description of the properties of atomic
 * variables. An {@code AtomicDouble} is used in applications such as atomic accumulation, and
 * cannot be used as a replacement for a {@link Double}. However, this class does extend {@code
 * Number} to allow uniform access by tools and utilities that deal with numerically-based classes.
 *

        assertEquals(Long.valueOf(1), stats.get(EventType.CONFIGURATION_CHANGE), "Should have 1 configuration event");
    }

    @Test
    @DisplayName("Test statistics accumulation")
    void testStatisticsAccumulation() {
        logger.logAuthentication(true, "user1", "DOMAIN", "192.168.1.1");
        logger.logAuthentication(false, "user2", "DOMAIN", "192.168.1.2");

 *   <li>keys automatically wrapped in {@code WeakReference}
 *   <li>values automatically wrapped in {@code WeakReference} or {@code SoftReference}
 *   <li>notification of evicted (or otherwise removed) entries
 *   <li>accumulation of cache access statistics
 * </ul>
 *
 * <p>These features are all optional; caches can be created using all or none of them. By default,

        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 {

        A accum = collector.supplier().get();
        for (T input : inputs) {
          collector.accumulator().accept(accum, input);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators left-to-right. */
    MERGE_LEFT_ASSOCIATIVE {
      @Override
      final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

    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);

        A accum = collector.supplier().get();
        for (T input : inputs) {
          collector.accumulator().accept(accum, input);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators left-to-right. */
    MERGE_LEFT_ASSOCIATIVE {
      @Override
      final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags with Enums { #tags-with-enums }

If you have a big application, you might end up accumulating **several tags**, and you would want to make sure you always use the **same tag** for related *path operations*.

In these cases, it could make sense to store the tags in an `Enum`.

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

    public void test_shutdown_withListener() {
        // Add shutdown listener
        TestShutdownListener listener = new TestShutdownListener();
        scriptExecutor.addShutdownListener(listener);

   * function to the current and given values.
   *
   * @param i the index to update
   * @param x the update value
   * @param accumulatorFunction the accumulator function
   * @return the previous value
   * @since 31.1
   */
  @CanIgnoreReturnValue
  public final double getAndAccumulate(int i, double x, DoubleBinaryOperator accumulatorFunction) {