// that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }
        return false;
    }

     */
    <T> Class<T> getPropertyType();

    /**
     * getterメソッドを返します。
     *
     * @return getterメソッド
     */
    Method getReadMethod();

    /**
     * getterメソッドを持っているかどうか返します。
     *
     * @return getterメソッドを持っているかどうか
     */
    boolean hasReadMethod();

    /**
     * setterメソッドを返します。
     *
     * @return setterメソッド
     */
    Method getWriteMethod();

    /**

    for (@SuppressWarnings("rawtypes") // class literals
    Class<? extends AbstractTester> testerClass : testers) {
      @SuppressWarnings("unchecked") // getting rid of the raw type, for better or for worse
      TestSuite testerSuite =
          makeSuiteForTesterClass((Class<? extends AbstractTester<?>>) testerClass);
      if (testerSuite.countTestCases() > 0) {
        suite.addTest(testerSuite);
      }

        return managedVersionMap;
    }

    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        } else if (!(other instanceof MavenProject)) {
            return false;
        }

        MavenProject that = (MavenProject) other;

        return Objects.equals(getArtifactId(), that.getArtifactId())

    /** The key of the message:  */
    public static final String ERRORS_front_header = "{errors.front_header}";

    /** The key of the message:  */
    public static final String ERRORS_front_footer = "{errors.front_footer}";

    /** The key of the message: <div class="alert alert-warning"> */
    public static final String ERRORS_front_prefix = "{errors.front_prefix}";

    /** The key of the message: </div> */

   * resizing the table, as well as populating slots with new Cells.
   * There is no need for a blocking lock; when the lock is not
   * available, threads try other slots (or the base).  During these
   * retries, there is increased contention and reduced locality,
   * which is still better than alternatives.
   *
   * Per-thread hash codes are initialized to random values.
   * Contention and/or table collisions are indicated by failed

     * Whether the artifact should be added to the classpath depends on other
     * dependency properties.
     *
     * @return if the artifact can be added to the class path
     *
     * @deprecated A value of {@code true} does not mean that the dependency should
     * be placed on the classpath. See {@code JavaPathType} instead for better analysis.
     */
    @Deprecated
    boolean isAddedToClasspath();

    short s = 2;
    Preconditions.checkState(boxedBoolean.booleanValue(), "", s);
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    /*
     * Don't bother testing: Preconditions defines a bunch of methods that accept a template (or
     * even entire message) that simultaneously:
     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *

   */
  private @interface GwtTransient {}

  /**
   * Compares strings in natural order except that null comes immediately before a given value. This
   * works better than Ordering.natural().nullsFirst() because, if null comes before all other
   * values, it lies outside the submap/submultiset ranges we test, and the variety of tests that
   * exercise null handling fail on those subcollections.
   */

    }

    @CanIgnoreReturnValue
    @Override
    Builder<E> combine(ImmutableSet.Builder<E> builder) {
      copyIfNecessary();
      Builder<E> other = (Builder<E>) builder;
      for (int i = 0; i < other.n; i++) {
        add(other.elements[i]);
      }
      return this;
    }

    /**
     * Returns a newly-created {@code ImmutableSortedSet} based on the contents of the {@code