boolean abort = true;

        DataStoreCrawlingException exception = new DataStoreCrawlingException(url, message, cause, abort);

        // Call aborted() multiple times
        assertTrue(exception.aborted());
        assertTrue(exception.aborted());
        assertTrue(exception.aborted());
    }

    public void test_getUrl_multipleCallsReturnSameValue() {

        super(message, e);
        this.url = url;
        this.abort = abort;
    }

    /**
     * Gets the URL where the crawling error occurred.
     *
     * @return the URL associated with this exception
     */
    public String getUrl() {
        return url;
    }

    /**
     * Checks whether the crawling process should be aborted due to this exception.
     *

- DRA: When the prioritized list feature was used in a request and the resulting number of allocated devices exceeded the number of allowed devices per claim, the scheduler aborted the attempt to allocate devices early. Previously, it tried to many different combinations, which could take a long time. ([#130593](https://github.com/kubernetes/kubernetes/pull/130593), [@mortent](https://github.com/mortent)) [SIG Apps, Node, Scheduling...

  public static class Chars extends SampleElements<Character> {
    public Chars() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super('b', 'a', 'c', 'd', 'e');
    }
  }

  public static class Enums extends SampleElements<AnEnum> {
    public Enums() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super(AnEnum.B, AnEnum.A, AnEnum.C, AnEnum.D, AnEnum.E);
    }

        stream(tags).of(stream -> stream.sorted().reduce((l, r) -> l + r).ifPresent(v -> buf.append(v)));
        buf.append(CACHE_KEY_SPLITTER);
        stream(roles).of(stream -> stream.sorted().reduce((l, r) -> l + r).ifPresent(v -> buf.append(v)));
        buf.append(CACHE_KEY_SPLITTER);
        stream(fields).of(stream -> stream.sorted().reduce((l, r) -> l + r).ifPresent(v -> buf.append(v)));

        item.setNewInputs(newInputs);

        // Inputs should already be sorted from constructor
        assertEquals("a", item.getInputs()[0]);

        // NewInputs not sorted yet
        assertEquals("9", item.getNewInputs()[0]);

        // Call sort
        item.sort();

        // Both should be sorted
        assertEquals("a", item.getInputs()[0]);
        assertEquals("m", item.getInputs()[1]);

                logger.debug("Client aborts this request.", e);
            }
        } catch (final Exception e) {
            if (!(e.getCause() instanceof ClientAbortException)) {
                throw new WebApiException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
            }
            logger.debug("Client aborts this request.", e);
        }
    }

    /**

      Comparator<? super E> comparator, Collection<? extends E> elements) {
    return copyOf(comparator, (Iterable<? extends E>) elements);
  }

  /**
   * Returns an immutable sorted set containing the elements of a sorted set, sorted by the same
   * {@code Comparator}. That behavior differs from {@link #copyOf(Iterable)}, which always uses the
   * natural ordering of the elements.
   *

import org.apache.logging.log4j.Logger;

/**
 * Factory class for managing and organizing document ingesters.
 * The factory maintains a sorted collection of ingesters based on their priority
 * and provides methods to add new ingesters and retrieve the current collection.
 *
 * Ingesters are automatically sorted by priority, with lower numbers having higher priority.
 */
public class IngestFactory {
    /** Logger instance for this class */

     * This method implements a time-based caching mechanism that refreshes the list
     * every 60 seconds to balance performance with up-to-date plugin discovery.
     *
     * @return array of data store names sorted alphabetically, never null
     */
    public String[] getDataStoreNames() {
        final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();
        if (now - lastLoadedTime > 60000L) {