<p><b>Note:</b> This will not automagically make a Mojo run when the plugin declaration is added
            to the POM. It merely enables the user to omit the {@code <phase>} element from the
            surrounding {@code <execution>} element.</p>
          </description>
        </field>
        <field>
          <name>executePhase</name>
          <version>1.0.0+</version>
          <type>String</type>

    @Override
    public boolean contains(@Nullable Object object) {
      return containsKey(object);
    }

    @Override
    public int count(@Nullable Object element) {
      Collection<V> values = map.get(element);
      return (values == null) ? 0 : values.size();
    }

    @Override
    public ImmutableSet<K> elementSet() {
      return keySet();
    }

    @Override

   * by delaying the per-stack-frame work until each element is accessed. Roughly speaking:
   *
   * <ul>
   *   <li>{@code getStackTrace} takes {@code stackSize} time to return but then negligible time to
   *       retrieve each element of the returned list.
   *   <li>{@code lazyStackTrace} takes negligible time to return but then {@code 1/stackSize} time
   *       to retrieve each element of the returned list (probably slightly more than {@code

	if err := d.DecodeElement(&parsedConfig, &start); err != nil {
		return err
	}

	if parsedConfig.ObjectLockEnabled != Enabled {
		return fmt.Errorf("only 'Enabled' value is allowed to ObjectLockEnabled element")
	}

	*config = Config(parsedConfig)
	return nil
}

// ToRetention - convert to Retention type.
func (config *Config) ToRetention() Retention {
	r := Retention{

      @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1L;

      @Override
      public boolean contains(@Nullable Object element) {
        Preconditions.checkNotNull(element);
        return super.contains(element);
      }
    }
    Collection<Integer> nums = new CollectionThatThrowsNullPointerException<>();
    Predicate<@Nullable Integer> isFalse = Predicates.in(nums);

  private static <E extends Comparable<? super E>> SortedSet<E> nullCheckedTreeSet(E[] elements) {
    SortedSet<E> set = newTreeSet();
    for (E element : elements) {
      // Explicit null check because TreeSet wrongly accepts add(null) when empty.
      set.add(checkNotNull(element));
    }
    return set;
  }

  public static class ContiguousSetGenerator extends AbstractContiguousSetGenerator {
    @Override

     * correct order—in order words, that it doesn't mix up big-endian and little-endian. The first
     * array has a smaller element at one index, and then the second array has a smaller element at
     * the next.
     */
    byte[] a0 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 99, 15, 16, 17};
    byte[] b0 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 99, 14, 15, 16, 17};

 * </ul>
 *
 * <h4>Full Inference for 4.1.0+ Models</h4>
 * <ul>
 *   <li><strong>ModelVersion Removal</strong>: Removes {@code <modelVersion>} element (inference enabled)</li>
 *   <li><strong>Root Attribute</strong>: Adds {@code root="true"} attribute to root project</li>
 *   <li><strong>Parent Element Trimming</strong>:
 *     <ul>
 *       <li>Removes parent {@code <groupId>} when child has no explicit groupId</li>

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify the first stack trace element is from this test method
        StackTraceElement firstElement = exception.getStackTrace()[0];
        assertEquals(this.getClass().getName(), firstElement.getClassName());

    List<E> containsNull = singletonList(null);
    assertTrue("addAll(n, containsNull) should return true", getList().addAll(0, containsNull));
    /*
     * We need (E) to force interpretation of null as the single element of a
     * varargs array, not the array itself
     */
    expectAdded(0, (E) null);
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)