assertThrows(IllegalArgumentException.class, () -> ImmutableDoubleArray.builder(-1));
  }

  /**
   * If there's a bug in builder growth, we wouldn't know how to expose it. So, brute force the hell
   * out of it for a while and see what happens.
   */
  public void testBuilder_bruteForce() {
    for (int i = 0; i < reduceIterationsIfGwt(100); i++) {

## Thanks to our Contributors

This release contains contributions from many people at Google, as well as:

 *   <li>It doesn't provide much control of threading.
 *   <li>It doesn't offer much monitoring.
 *   <li>It doesn't propagate exceptions, so apps don't have a way to react to them.
 *   <li>It doesn't interoperate well with RxJava, coroutines, and other more commonly used
 *       alternatives.
 *   <li>It imposes requirements on the lifecycle of its subscribers. For example, if an event

        // language=javascript
        return """
            <script type="text/javascript">
                function getAllErrorCorrections() {
                    var changeElements = document.querySelectorAll(".well pre");
                    var result = [];
                    changeElements.forEach((val, idx) => result.push(JSON.parse(val.textContent)));
                    return result;
                }

  /**
   * Returns a new thread-safe interner which retains a weak reference to each instance it has
   * interned, and so does not prevent these instances from being garbage-collected. This most
   * likely does not perform as well as {@link #newStrongInterner}, but is the best alternative when
   * the memory usage of that implementation is unacceptable.
   */
  @GwtIncompatible // java.lang.ref.WeakReference

 * the methods of the delegate. For example, overriding {@link #put} alone <i>will not</i> change
 * the behavior of {@link #putAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

    private byte[] largeTestData;

    @BeforeEach
    public void setUp() {
        compressionService = new DefaultCompressionService();

        // Create test data with patterns that should compress well
        testData = generateTestData(1024);
        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {

                logger.debug("Lifecycle {}", lifecycle);
            }
            lifecyclesPrinted = true;
        }

        // If people are going to make their own lifecycles then we need to tell people how to namespace them correctly
        // so that they don't interfere with internally defined lifecycles.

        Map<String, Lifecycle> phaseToLifecycleMap = new HashMap<>();

                new TestStringSetGenerator() {
                  @Override
                  protected Set<String> create(String[] elements) {
                    // Put the sets in different orders for the hell of it
                    return union(
                        new LinkedHashSet<>(asList(elements[0], elements[1], elements[2])),
                        new LinkedHashSet<>(asList(elements[1], elements[0], elements[2])));

    assertThrows(IllegalArgumentException.class, () -> ImmutableIntArray.builder(-1));
  }

  /**
   * If there's a bug in builder growth, we wouldn't know how to expose it. So, brute force the hell
   * out of it for a while and see what happens.
   */
  public void testBuilder_bruteForce() {
    for (int i = 0; i < reduceIterationsIfGwt(100); i++) {