if (!(jApiCompatibility instanceof JApiMethod) || !((JApiMethod) jApiCompatibility).getOldMethod().isPresent()) {
            return Optional.empty();
        }
        JApiMethod jApiMethod = (JApiMethod) jApiCompatibility;

    assertEquals(expected.length(), source.length());
  }

  public void testLengthIfKnown() throws IOException {
    Optional<Long> lengthIfKnown = source.lengthIfKnown();
    if (lengthIfKnown.isPresent()) {
      assertEquals(expected.length(), (long) lengthIfKnown.get());
    }
  }

  public void testReadLines_withProcessor() throws IOException {
    List<String> list =
        source.readLines(

   */
  private static boolean matchesType(
      Optional<PublicSuffixType> desiredType, Optional<PublicSuffixType> actualType) {
    return desiredType.isPresent() ? desiredType.equals(actualType) : actualType.isPresent();
  }

  /** Returns the domain name, normalized to all lower case. */
  @Override
  public String toString() {
    return name;
  }

  /**

        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {
        return ((Map<?, ?>) value).isEmpty();
      } else if (value instanceof Optional) {
        return !((Optional) value).isPresent();
      } else if (value.getClass().isArray()) {
        return Array.getLength(value) == 0;
      }
      return false;
    }

    /**

    }

    @Nonnull
    @Override
    public Optional<Path> getPath(Project project) {
        Optional<ProducedArtifact> mainArtifact = project.getMainArtifact();
        if (mainArtifact.isPresent()) {
            return artifactManager.getPath(mainArtifact.get());
        }
        return Optional.empty();
    }

    @Nonnull
    @Override

    //                                                                           =========
    protected boolean isLoginRequired() {
        if (fessConfig.isLoginRequired() && !fessLoginAssist.getSavedUserBean().isPresent()) {
            return true;
        }
        return false;
    }

    protected void buildFormParams(final SearchForm form) {

        final HttpSession session = request.getSession(false);

   * exceptions thrown from the test do not cause this check to fail.
   */
  @RegisterExtension
  val noDataLeftBehind =
    AfterEachCallback { context: ExtensionContext ->
      if (context.executionException.isPresent) return@AfterEachCallback
      assertThat(data.readByteString().hex(), "Data not empty")
        .isEqualTo("")
    }

  // Mutually exclusive. Use the one corresponding to the peer whose behavior you wish to test.

    LinkedHashSet<Class<?>> candidateClasses = Sets.newLinkedHashSet();
    for (Class<?> cls : classes) {
      Optional<String> testedClassName = TEST_SUFFIX.chop(cls.getName());
      if (testedClassName.isPresent()) {
        Class<?> testedClass = classMap.get(testedClassName.get());
        if (testedClass != null) {
          testClasses.put(testedClass, cls);
        }
      } else {
        candidateClasses.add(cls);

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}

// Unacceptable
String value
if (!getSomeProperty().isPresent()) {
   value = "convention"
} else {
   value = getSomeProperty().get()
}

// Also unacceptable
String value = getSomeProperty().getOrElse("convention")

// This should be always:

   */
  private static boolean matchesType(
      Optional<PublicSuffixType> desiredType, Optional<PublicSuffixType> actualType) {
    return desiredType.isPresent() ? desiredType.equals(actualType) : actualType.isPresent();
  }

  /** Returns the domain name, normalized to all lower case. */
  @Override
  public String toString() {
    return name;
  }

  /**