Providers.setProviderList(providers);
    }
  }

  public void testMultipleUpdates() throws Exception {
    Mac mac = Mac.getInstance("HmacSHA1");
    mac.init(SHA1_KEY);
    mac.update("hello".getBytes(UTF_8));
    mac.update("world".getBytes(UTF_8));

    assertEquals(
        HashCode.fromBytes(mac.doFinal()),
        Hashing.hmacSha1(SHA1_KEY)
            .newHasher()
            .putString("hello", UTF_8)

   * <p>Changes to the returned collection will update the underlying multimap, and vice versa.
   */
  Collection<V> get(@ParametricNullness K key);

  /**
   * Returns a view collection of all <i>distinct</i> keys contained in this multimap. Note that the
   * key set contains a key if and only if this multimap maps that key to at least one value.
   *
   * <p>Changes to the returned set will update the underlying multimap, and vice versa. However,

 * views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedSetMultimap}.
 *

 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum MultisetFeature implements Feature<Multiset> {
  /**
   * Indicates that elements from {@code Multiset.entrySet()} update to reflect changes in the
   * backing multiset.
   */
  ENTRIES_ARE_VIEWS;

  @Override
  public Set<Feature<? super Multiset>> getImpliedFeatures() {
    return Collections.emptySet();
  }

          java-version: 11
          distribution: 'zulu'
          cache: 'maven'
      - name: 'Generate latest docs'
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

 * views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedListMultimap}.
 *
 * <p>See the Guava User Guide article on <a href=

            }
          }
        }
        if (done) {
          break;
        }
      }
    }
  }

  /**
   * Multiple threads using same array of counters successfully update a number of times equal to
   * total count
   */
  public void testCountingInMultipleThreads() throws InterruptedException {
    final AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);

            }
          }
        }
        if (done) {
          break;
        }
      }
    }
  }

  /**
   * Multiple threads using same array of counters successfully update a number of times equal to
   * total count
   */
  public void testCountingInMultipleThreads() throws InterruptedException {
    final AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);

     * iterator's next element and pass it to the reference iterator through this method so it can
     * return the same element. This enables the assertion to pass and the reference iterator to
     * properly update its state.
     */
    void promoteToNext(E e) {
      if (nextElements.remove(e)) {
        nextElements.push(e);
      } else {
        throw new UnknownElementException(nextElements, e);
      }
    }

   * out.
   */
  long timeoutMillis() {
    return SHORT_DELAY_MS / 4;
  }

  /** Returns a new Date instance representing a time delayMillis milliseconds in the future. */
  Date delayedDate(long delayMillis) {
    return new Date(System.currentTimeMillis() + delayMillis);
  }

  /** The first exception encountered if any threadAssertXXX method fails. */