if (methodDesc == null) {
            return null;
        }
        final Object value = methodDesc.invoke(annotation);
        if (value == null || "".equals(value)) {
            return null;
        }
        return value;
    }

   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override
  boolean equals(@Nullable Object object);

  static final class Impl implements One, Two, Three, Four, Five, Serializable {
    final int value;

    Impl(int value) {
      this.value = value;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return obj instanceof Impl && value == ((Impl) obj).value;
    }

    @Override
    public int hashCode() {
      return value;
    }

    @Override

    // requireNonNull is safe because we guarantee that the first `size` elements are non-null.
    return (E) requireNonNull(array[index]);
  }

  // TODO(lowasser): benchmark optimizations for equals() and see if they're worthwhile

  // redeclare to help optimizers with b/310253115
  @SuppressWarnings("RedundantOverride")
  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {

        }, "scheduledJobBhv");

        ComponentUtil.setFessConfig(new TestFessConfig() {
            @Override
            public boolean isSchedulerTarget(String target) {
                return "all".equals(target);
            }
        });

        int count = crawlJob.getRunningJobCount();
        assertEquals(2, count); // job1 and job3 are running
    }

                if (getParamValue(localParams, "event.create", "create").equals(eventType)
                        || getParamValue(localParams, "event.modify", "modify").equals(eventType)) {
                    // updated file
                    addDocument(localParams, dataMap);
                } else if (getParamValue(localParams, "event.delete", "delete").equals(eventType)) {
                    // deleted file

    public List<String> getAllowedWarnings() {
        return allowedWarnings;
    }

    @Override
    public boolean shouldApply(RestTestContext testContext) {
        return testName == null || testContext.getTestName().equals(testName);
    }

    @Input
    @Optional
    public String getTestName() {
        return testName;
    }

  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ImmutableEnumSet) {
      object = ((ImmutableEnumSet<?>) object).delegate;
    }
    return delegate.equals(object);
  }

  @Override
  boolean isHashCodeFast() {
    return true;
  }

   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override
  boolean equals(@Nullable Object obj);

    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final KuromojiItem other = (KuromojiItem) obj;
        if (!Objects.equals(pos, other.pos) || !Objects.equals(reading, other.reading) || !Objects.equals(segmentation, other.segmentation)