abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */
  abstract X minus(X a, X b);

  /** Rounds {@code x} to a {@code double}. */
  final double roundToDouble(X x, RoundingMode mode) {
    checkNotNull(x, "x");
    checkNotNull(mode, "mode");
    double roundArbitrarily = roundToDoubleArbitrarily(x);
    if (Double.isInfinite(roundArbitrarily)) {

 components or in plugins/component not requiring compatibility with previous Maven versions.

+-----+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyClass
{
   final Logger logger = LoggerFactory.getLogger( MyClass.class );
}
+-----+

* Logger Name

 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
class DefaultModelProblemCollector implements ModelProblemCollectorExt {

    private final ModelBuildingResult result;

    private List<ModelProblem> problems;

    private String source;

    private Model sourceModel;

    private Model rootModel;

/**
 * Tests {@link FileProfileActivator}.
 *
 */
@Deprecated
class FileProfileActivatorTest extends AbstractProfileActivatorTest<FileProfileActivator> {

    @TempDir
    Path tempDir;

    private final DefaultProfileActivationContext context = new DefaultProfileActivationContext();

    @BeforeEach
    @Override
    void setUp() throws Exception {
        activator = new FileProfileActivator()

 */
@SuppressWarnings("deprecation")
@Named
public class DefaultProjectArtifactFactory implements ProjectArtifactFactory {
    private final ArtifactFactory artifactFactory;

    @Inject
    public DefaultProjectArtifactFactory(ArtifactFactory artifactFactory) {
        this.artifactFactory = artifactFactory;
    }

    @Override

System.out.println("Crawling completed");
```

### Custom Content Extractor

```java
public class CustomExtractor extends AbstractExtractor {
    @Override
    public ExtractData getText(final InputStream inputStream, final Map<String, String> params) {
        // Custom extraction logic
        ExtractData extractData = new ExtractData();
        // ... implementation
        return extractData;
    }
}

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Locale;

public class GradleKotlinDslReferencePlugin implements Plugin<Project> {

    private static final String TASK_NAME = "dokkaGeneratePublicationHtml";

    @Override
    public void apply(Project project) {

  public NavigableSet<K> descendingKeySet() {
    return descendingMap().navigableKeySet();
  }

  @Override
  public NavigableMap<K, V> descendingMap() {
    return new DescendingMap();
  }

  private final class DescendingMap extends Maps.DescendingMap<K, V> {
    @Override
    NavigableMap<K, V> forward() {
      return AbstractNavigableMap.this;
    }

    @Override
    Iterator<Entry<K, V>> entryIterator() {

        assertEquals(0, permissions.length);
    }

    @Test
    public void test_getPermissions_withLdapConfig() {
        // Test with LDAP configuration
        final AtomicBoolean activityHelperCalled = new AtomicBoolean(false);
        final AtomicReference<String[]> rolesFromCallback = new AtomicReference<>();

        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override

            assertTrue(testFacetInfo.getAddedQueries().contains(query));
        }
    }

    // Helper classes for testing
    private static class TestFacetInfo extends FacetInfo {
        private final List<String> addedQueries = new ArrayList<>();

        @Override
        public void addQuery(String s) {
            addedQueries.add(s);
        }

        public List<String> getAddedQueries() {