* When {@code --infer} option is enabled, applies inference optimizations to remove redundant information:
 *
 * <h4>Limited Inference for 4.0.0 Models (Maven 3.x POMs)</h4>
 * <ul>
 *   <li><strong>Child GroupId Removal</strong>: Removes child {@code <groupId>} when it matches parent groupId</li>
 *   <li><strong>Child Version Removal</strong>: Removes child {@code <version>} when it matches parent version</li>
 * </ul>
 *

        classes['NewSub'].superclass = classes['NewBase']

        apiClass.compatibilityChanges >> [new JApiCompatibilityChange(JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS)]
    }

    def "method removal can be reported if current class is first public class"() {
        given:
        apiClass.oldClass >> Optional.of(classes['OldBase'])
        apiClass.newClass >> Optional.of(classes['NewBase'])

        when:

  public void testAwait_countDownLatch() {
    CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/260137033
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable

   * creation and removal (including automatic removal of zeroes). If the modification of an
   * AtomicInteger results in zero, we compareAndSet the value to zero; if that succeeds, we remove
   * the entry from the Map. If another operation sees a zero in the map, it knows that the entry is
   * about to be removed, so this operation may remove it (often by replacing it with a new
   * AtomicInteger).
   */

  public void testAwait_countDownLatch() {
    CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/260137033
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable

            var dependencyElements = dependencies.children("dependency").toList();
            assertEquals(1, dependencyElements.size(), "Should have only one dependency after duplicate removal");
        }

        @Test
        @DisplayName("should remove duplicate dependencies in regular dependencies")
        void shouldRemoveDuplicateDependenciesInRegularDependencies() throws Exception {
            String pomXml = """

    private static final List<JApiCompatibilityChangeType> IGNORED_CHANGE_TYPES = ImmutableList.of(
        JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS, // the removal of the method will be reported
        JApiCompatibilityChangeType.INTERFACE_REMOVED,            // the removed methods will be reported
        JApiCompatibilityChangeType.INTERFACE_ADDED               // the added methods will be reported
    );

 *   <li>Removes managed dependencies that are not used by direct dependencies</li>
 *   <li>Retains only managed dependencies that appear in the resolved dependency tree</li>
 * </ul>
 * <p>
 * <b>Repository and Profile Pruning</b>: The consumer POM removal strategy:
 * <ul>
 *   <li>Removes the central repository (only non-central repositories are kept)</li>

    'ignore:datetime\.datetime\.utcfromtimestamp\(\) is deprecated and scheduled for removal in a future version\..*:DeprecationWarning:sqlalchemy',
    # Trio 24.1.0 raises a warning from attrs
    # Ref: https://github.com/python-trio/trio/pull/3054
    # Remove once there's a new version of Trio
    'ignore:The `hash` argument is deprecated*:DeprecationWarning:trio',
]

[tool.coverage.run]

        return fessConfig.getCrawlerDocumentMaxSymbolTermSizeAsInteger();
    }

    /**
     * Checks if duplicate term removal is enabled in configuration.
     *
     * @return true if duplicate terms should be removed, false otherwise
     */
    protected boolean isDuplicateTermRemoved() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();