* will never throw {@link ConcurrentModificationException}, and guarantees to traverse elements
   * as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect
   * any modifications subsequent to construction.
   *
   * @return an iterator over the elements in this queue
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public Iterator<E> iterator() {

     */
    @Nullable ObjectCountHashMap<E> contents;

    /**
     * If build() has been called on the current contents multiset, we need to copy it on any future
     * modifications, or we'll modify the already-built ImmutableMultiset.
     */
    boolean buildInvoked = false;

    /**
     * In the event of a setCount(elem, 0) call, we may need to remove elements, which destroys the

            latch.countDown();
        });

        t1.start();
        t2.start();

        assertTrue(latch.await(5, TimeUnit.SECONDS));
        // The exact size may vary due to concurrent modifications, just check it's not empty
        assertTrue(execJob.jvmOptions.size() > 0);
    }

    // Test pattern matching in custom properties
    @Test
    public void test_customProperties_complexPattern() {

   * elements.length) are all {@code null}.
   */
  @VisibleForTesting transient @Nullable Object @Nullable [] elements;

  /**
   * Keeps track of metadata like the number of hash table bits and modifications of this data
   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note
   * that we choose not to make this volatile, so we do less of a "best effort" to track such

  private transient @Nullable Node<K, V> tail; // the tail for all keys
  private transient Map<K, KeyList<K, V>> keyToKeyList;
  private transient int size;

  /*
   * Tracks modifications to keyToKeyList so that addition or removal of keys invalidates
   * preexisting iterators. This does *not* track simple additions and removals of values
   * that are not the first to be added or last to be removed for their key.

   * ConcurrentModificationException}, and guarantees to traverse elements as they existed upon
   * construction of the iterator, and may (but is not guaranteed to) reflect any modifications
   * subsequent to construction.
   *
   * @return an iterator over the elements in this queue in proper sequence
   */
  @CanIgnoreReturnValue
  @Override
  public Iterator<E> iterator() {

    /* UnsupportedOperationException on direct modifications. */
    assertThrows(UnsupportedOperationException.class, () -> unmod.put(4, "four"));
    assertThrows(UnsupportedOperationException.class, () -> unmod.forcePut(4, "four"));
    assertThrows(UnsupportedOperationException.class, () -> unmod.putAll(singletonMap(4, "four")));

    /* UnsupportedOperationException on indirect modifications. */

  private transient @Nullable Node<K, V> tail; // the tail for all keys
  private transient Map<K, KeyList<K, V>> keyToKeyList;
  private transient int size;

  /*
   * Tracks modifications to keyToKeyList so that addition or removal of keys invalidates
   * preexisting iterators. This does *not* track simple additions and removals of values
   * that are not the first to be added or last to be removed for their key.

   * elements.length) are all {@code null}.
   */
  @VisibleForTesting transient @Nullable Object @Nullable [] elements;

  /**
   * Keeps track of metadata like the number of hash table bits and modifications of this data
   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note
   * that we choose not to make this volatile, so we do less of a "best effort" to track such

 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}
 * implementations, synchronization is unnecessary between a thread that writes to one cell and a
 * thread that reads from another.
 *