- Parse GSA collections
   - Create corresponding WebConfig or FileConfig entries
   - Convert URL patterns to Fess regex patterns
   - Set up LabelType (access control labels) if defined

**Step 3: Verify Imported Configurations**

After import, verify:
- **Crawler > Web**: Check web crawling configurations
- **Crawler > File**: Check file crawling configurations (SMB, FTP)
- **System > General**: Verify URL patterns and filters

  public NavigableSet<V> get(@ParametricNullness K key) {
    return (NavigableSet<V>) super.get(key);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code TreeMultimap} has unique sorted keys, this method returns a {@link
   * NavigableSet}, instead of the {@link java.util.Set} specified in the {@link Multimap}
   * interface.
   *
   * @since 14.0 (present with return type {@code SortedSet} since 2.0)

                if (projectsToEnableNullaway.isNotEmpty()) {
                    println("${toEnableCount} ${projectS(toEnableCount)} with checked dependencies are ready to be worked on:")
                    projectsToEnableNullaway.sorted().forEach {
                        println("  * $it")
                    }
                } else if (projectsWithUncheckedDeps.isNotEmpty()) {

import org.junit.jupiter.api.Test


class SortAcceptedApiChangesTaskIntegrationTest : AbstractAcceptedApiChangesMaintenanceTaskIntegrationTest() {
    @Test
    fun `verify misordered changes can be sorted`() {
        //language=JSON
        firstAcceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {

    checkNonnegative(k, "k");

    if (k == 0 || !iterator.hasNext()) {
      return emptyList();
    } else if (k >= Integer.MAX_VALUE / 2) {
      // k is really large; just do a straightforward sorted-copy-and-sublist
      ArrayList<E> list = Lists.newArrayList(iterator);
      sort(list, this);
      if (list.size() > k) {
        list.subList(k, list.size()).clear();
      }
      list.trimToSize();

                logger.debug("Path does not exist: path={}", dir);
            }
            return;
        }
        try (Stream<Path> walk = Files.walk(dir, FileVisitOption.FOLLOW_LINKS)) {
            walk.sorted(Comparator.reverseOrder()).forEach(f -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("Deleting: path={}", f);
                }
                try {

            if scope not in scopes:
                scopes.append(scope)
        return scopes

    @cached_property
    def cache_key(self) -> DependencyCacheKey:
        scopes_for_cache = (
            tuple(sorted(set(self.oauth_scopes or []))) if self._uses_scopes else ()
        )
        return (
            self.call,
            scopes_for_cache,
            self.computed_scope or "",
        )

    @cached_property

   * FluentIterable} in the order specified by {@code comparator}. To produce an {@code
   * ImmutableList} sorted by its natural ordering, use {@code toSortedList(Ordering.natural())}.
   *
   * <p><b>{@code Stream} equivalent:</b> pass {@link ImmutableList#toImmutableList} to {@code
   * stream.sorted(comparator).collect()}.
   *
   * @param comparator the function by which to sort list elements

            } finally {
                // Clean up - delete all files in the directory first
                try {
                    Files.walk(tempDir)
                            .sorted(java.util.Comparator.reverseOrder())
                            .forEach(path -> {
                                try {
                                    Files.deleteIfExists(path);

    /**
     * Invoked after all MavenProject instances have been created.
     *
     * This callback is intended to allow extensions to manipulate MavenProjects
     * before they are sorted and actual build execution starts.
     *
     * @param session the Maven session
     * @throws MavenExecutionException in case of issue
     */