// ----------------------------------------------------------------------

    /**
     * How the test project is set up:
     *
     * 1. dependencyManagement lists dependencies on a & b,
     *    with an exclusion on c in b.
     * 2. the child project lists a dependency on project a only
     * 3. a depends on b (which is transitive to the child project),
     *    and b depends on c.
     *

        }

        if (!d.getExclusions().isEmpty()) {
            List<String> exclusions = new ArrayList<>();

            for (Exclusion exclusion : d.getExclusions()) {
                exclusions.add(exclusion.getGroupId() + ':' + exclusion.getArtifactId());
            }

            artifact.setDependencyFilter(new ExcludesArtifactFilter(exclusions));
        }

        return artifact;
    }

			<groupId>org.junit.platform</groupId>
			<artifactId>junit-platform-runner</artifactId>
			<version>1.10.3</version>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>junit</groupId>
					<artifactId>junit</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.hamcrest</groupId>
			<artifactId>hamcrest</artifactId>
			<version>2.2</version>

import org.codelibs.fess.crawler.entity.UrlQueueImpl;

/**
 * The {@code MemoryDataHelper} class provides a helper for managing crawler data in memory.
 * It stores URL queues, access results, and URL patterns for inclusion and exclusion.
 * This class is designed to be used in a single-threaded environment or with external synchronization.
 *
 * <p>It uses {@code Map} and {@code Queue} data structures to hold the data. The class provides

        }
    }

    /**
     * Determines whether the specified URL is crawlable based on the exclusion pattern
     * provided in the {@code paramMap}. If the {@code URL_EXCLUDE_PATTERN} key exists in
     * the parameter map, its value is used as a regular expression pattern to match against
     * the given URL. If the URL matches the exclusion pattern, the method returns {@code false},

     */
    @Nullable
    Boolean getOptional();

    /**
     * {@return transitive dependencies to exclude}
     */
    @Nonnull
    Collection<Exclusion> getExclusions();

  @BeforeExperiment
  void setUp() throws Exception {
    if (state != State.NOT_DONE && (numListeners != 0 || numThreads != 0)) {
      throw new SkipThisScenarioException();
    }
  }

  // This exclusion doesn't exclude the TOMBSTONE objects we set. So 'done' NEW futures will look
  // larger than they are.
  @SuppressWarnings("FutureReturnValueIgnored")

        /*

        Logic for transitive global exclusions

        List<String> exclusions = new ArrayList<String>();

        for ( Dependency d : project.getDependencies() )
        {
            if ( d.getExclusions() != null )
            {
                for ( Exclusion e : d.getExclusions() )
                {
                    exclusions.add(  e.getGroupId() + ":" + e.getArtifactId() );
                }

 * with {@link PopularWordsResponse}. It allows specifying various criteria for retrieving popular words,
 * such as index, size, tags, roles, fields, languages, and exclusion words.
 *
 * <p>Key functionalities include:</p>
 * <ul>
 *   <li>Setting the target index for the search.</li>
 *   <li>Limiting the number of results (size).</li>

///

/// warning | Attention

Pour faire cela, vous devez vous assurer que chacun de vos *chemin* ait un nom unique.

Même s'ils se trouvent dans des modules différents (fichiers Python).

///

## Exclusion d'OpenAPI

Pour exclure un *chemin* du schéma OpenAPI généré (et donc des systèmes de documentation automatiques), utilisez le paramètre `include_in_schema` et assignez-lui la valeur `False` :