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

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

        // Should contain this test method in stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().contains("testStackTracePreservation")) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);

	Location string   `xml:"LocationConstraint"`
}

// DeleteObjectsRequest - xml carrying the object key names which needs to be deleted.
type DeleteObjectsRequest struct {
	// Element to enable quiet mode for the request
	Quiet bool
	// List of objects to be deleted
	Objects []ObjectToDelete `xml:"Object"`

    @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

  public void testRemoveAtIndex_last() {
    runRemoveTest(getNumElements() - 1);
  }

  private void runRemoveTest(int index) {
    assertEquals(
        Platform.format("remove(%d) should return the element at index %d", index, index),
        getList().get(index),
        getList().remove(index));
    List<E> expected = copyToList(createSamplesArray());
    expected.remove(index);
    expectContents(expected);
  }

        assertNotSame(thrower1, thrower2);
    }

    // Helper method to check if array contains a value
    private boolean containsValue(String[] array, String value) {
        for (String element : array) {
            if (element.equals(value)) {
                return true;
            }
        }
        return false;
    }

      return ImmutableSet.copyOf(elements);
    }
  }

  public static class DegeneratedImmutableSetGenerator extends TestStringSetGenerator {
    @SuppressWarnings("DistinctVarargsChecker") // deliberately testing deduplication
    @Override
    protected Set<String> create(String[] elements) {
      return ImmutableSet.of(elements[0], elements[0]);
    }
  }

     * 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};

      return samples;
    }

    @Override
    public Set<K> create(Object... elements) {
      @SuppressWarnings("unchecked")
      K[] keysArray = (K[]) elements;

      // Start with a suitably shaped collection of entries
      Collection<Entry<K, V>> originalEntries = mapGenerator.getSampleElements(elements.length);

      // Create a copy of that, with the desired value for each key

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