pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
    SPDX-License-Identifier: Apache-2.0
    Copyright Red Hat Inc. and Hibernate Authors
-->
<!-- child.project.url.inherit.append.path is weird but necessary to have correct URLs in flattened POMs,
     see XSD for more info. -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
         child.project.url.inherit.append.path="false">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.hibernate.search</groupId>
    <artifactId>hibernate-search-parent</artifactId>
    <version>8.3.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <name>Hibernate Search</name>
    <description>Hibernate Search Root POM</description>

    <url>https://hibernate.org/search/</url>

    <inceptionYear>2006</inceptionYear>

    <issueManagement>
        <system>JIRA</system>
        <url>https://hibernate.atlassian.net/browse/HSEARCH</url>
    </issueManagement>

    <!-- The various child.*.append.path are weird but necessary to have correct URLs in flattened POMs,
         see XSD for more info. -->
    <scm child.scm.connection.inherit.append.path="false"
         child.scm.developerConnection.inherit.append.path="false"
         child.scm.url.inherit.append.path="false">
        <connection>scm:git:git://github.com/hibernate/hibernate-search.git</connection>
        <developerConnection>scm:git:git@github.com:hibernate/hibernate-search.git</developerConnection>
        <url>http://github.com/hibernate/hibernate-search</url>
        <tag>HEAD</tag>
    </scm>

    <organization>
        <name>Hibernate</name>
        <url>http://www.hibernate.org</url>
    </organization>

    <licenses>
        <license>
            <name>Apache-2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
            <comments>See also: https://hibernate.org/license</comments>
        </license>
    </licenses>

    <ciManagement>
        <system>Jenkins</system>
        <url>https://ci.hibernate.org/job/hibernate-search/</url>
    </ciManagement>

    <developers>
        <developer>
            <id>epbernard</id>
            <name>Emmanuel Bernard</name>
            <email>emmanuel@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/emmanuel-bernard/</url>
        </developer>
        <developer>
            <id>hardy.ferentschik</id>
            <name>Hardy Ferentschik</name>
            <email>hferents@redhat.com</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/hardy-ferentschik/</url>
        </developer>
        <developer>
            <id>sannegrinovero</id>
            <name>Sanne Grinovero</name>
            <email>sanne@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/sanne-grinovero/</url>
        </developer>
        <developer>
            <id>gunnar.morling</id>
            <name>Gunnar Morling</name>
            <email>gunnar@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/gunnar-morling/</url>
        </developer>
        <developer>
            <id>davide.dalto</id>
            <name>Davide D'Alto</name>
            <email>davide@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/davide-dalto/</url>
        </developer>
        <developer>
            <id>guillaume.smet</id>
            <name>Guillaume Smet</name>
            <email>guillaume@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/guillaume-smet/</url>
        </developer>
        <developer>
            <id>yoann.rodiere</id>
            <name>Yoann Rodière</name>
            <email>yoann@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/yoann-rodiere/</url>
        </developer>
        <developer>
            <id>fabio.ercoli</id>
            <name>Fabio Massimo Ercoli</name>
            <email>fabio@hibernate.org</email>
            <organization>Red Hat, Inc.</organization>
            <url>http://in.relation.to/fabio-massimo-ercoli/</url>
        </developer>
        <developer>
            <id>mincong-h</id>
            <name>Mincong Huang</name>
            <email>mincong.h@gmail.com</email>
            <url>http://mincong-h.github.io</url>
        </developer>
    </developers>

    <mailingLists>
        <mailingList>
            <name>Hibernate Announcements</name>
            <post>hibernate-announce@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-announce</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-announce</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-dev/</archive>
        </mailingList>
        <mailingList>
            <name>Hibernate Commit Notifications</name>
            <post>hibernate-commits@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-commits</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-commits</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-commits/</archive>
        </mailingList>
        <mailingList>
            <name>Hibernate Developers</name>
            <post>hibernate-dev@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-dev</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-dev</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-dev/</archive>
            <otherArchives>
                <otherArchive>http://www.mail-archive.com/hibernate-dev%40lists.jboss.org/index.html</otherArchive>
            </otherArchives>
        </mailingList>
        <mailingList>
            <name>Hibernate Issue Notifications</name>
            <post>hibernate-issues@lists.jboss.org</post>
            <subscribe>https://lists.jboss.org/mailman/listinfo/hibernate-issues</subscribe>
            <unsubscribe>https://lists.jboss.org/mailman/listinfo/hibernate-issues</unsubscribe>
            <archive>http://lists.jboss.org/pipermail/hibernate-issues/</archive>
        </mailingList>
    </mailingLists>

    <modules>
        <module>bom/public</module>
        <module>bom/platform-common</module>
        <module>bom/platform</module>
        <module>bom/platform-next</module>
        <module>build/parents/relocation</module>
        <module>build/parents/build</module>
        <module>build/enforcer</module>
        <module>build/config</module>
        <module>build/parents/internal</module>
        <module>util/internal/test/common</module>
        <module>util/internal/test/orm</module>
        <module>build/parents/public</module>
        <module>util/common</module>
        <module>engine</module>
        <module>backend/lucene</module>
        <module>backend/elasticsearch</module>
        <module>backend/elasticsearch-aws</module>
        <module>backend/elasticsearch-client/elasticsearch-rest4-client</module>
        <module>backend/elasticsearch-client/elasticsearch-rest5-client</module>
        <module>backend/elasticsearch-client/opensearch-rest-client</module>
        <module>mapper/pojo-base</module>
        <module>mapper/pojo-standalone</module>
        <module>mapper/orm</module>
        <module>mapper/orm-outbox-polling</module>
        <module>mapper/orm-coordination-outbox-polling</module>
        <module>mapper/orm-batch-jsr352/core</module>
        <module>mapper/orm-batch-jsr352/jberet</module>
        <module>mapper/orm-jakarta-batch/core</module>
        <module>mapper/orm-jakarta-batch/jberet</module>
        <module>v5migrationhelper/engine</module>
        <module>v5migrationhelper/orm</module>
        <module>util/internal/integrationtest</module>
        <module>build/parents/integrationtest</module>
        <module>build/parents/springtest</module>
        <module>integrationtest</module>
        <module>documentation</module>
        <module>lucene-next</module>
        <module>metamodel/metamodel-processor</module>
    </modules>

    <properties>
        <!--
             Version to be used as baseline for API/SPI change reports,
             and for the migration guide
          -->
        <version.org.hibernate.search.previous-stable>8.2.0.Final</version.org.hibernate.search.previous-stable>

        <!-- Build settings -->

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- JDK version required for the build; we target 17 but require at least 21 for the build -->
        <!-- Adjust contributing guide when changing the minimum required JDK version -->
        <jdk.min.version>25</jdk.min.version>
        <!-- The lowest supported version of Java for applications using Hibernate Search -->
        <!-- Set statically, independently from the current JDK: we want our code to comply with this version -->
        <!-- Adjust the contributing guide when changing the release Java version -->
        <java-version.main.release>17</java-version.main.release>
        <java-version.main.compiler.java_home>${java.home}</java-version.main.compiler.java_home>
        <java-version.main.compiler>${java-version.main.compiler.java_home}/bin/javac</java-version.main.compiler>
        <!-- The versions of Java documented as supported for applications using Hibernate Search -->
        <java-version.main.compatible.expected.text>17, 21 or 25</java-version.main.compatible.expected.text>
        <!-- The version of test bytecode, useful for testing compatibility with newer JDKs -->
        <!-- Set to the expected version of the JDK running Maven by default, but overridden on CI -->
        <java-version.test.release>${jdk.min.version}</java-version.test.release>
        <java-version.test.compiler.java_home>${java.home}</java-version.test.compiler.java_home>
        <java-version.test.compiler>${java-version.test.compiler.java_home}/bin/javac</java-version.test.compiler>
        <!-- IMPORTANT: For Java 8, this must be the path to the JDK, not to the JRE -->
        <java-version.test.launcher.java_home>${java-version.test.compiler.java_home}</java-version.test.launcher.java_home>
        <java-version.test.launcher>${java-version.test.launcher.java_home}/bin/java</java-version.test.launcher>

        <!--
             The absolute path to the root project directory.
             This property is set by the build-helper plugin.
             We initialize it to some crude, potentially wrong value,
             because the Sonar Maven plugin uses this property indirectly,
             but ignores any change made by other plugins.
             This default value is the best we can do without the help of a Maven plugin.

             Useful resources:
              - https://www.mojohaus.org/build-helper-maven-plugin/rootlocation-mojo.html
          -->
        <rootProject.directory>${user.dir}</rootProject.directory>
        <!--
            The absolute path to an empty subdirectory of the root project.
            This is used in places where we need a path to an existing, empty directory,
            such as when fooling Sonar into thinking there is no "main" source in a project.
         -->
        <rootProject.empty.directory>${rootProject.directory}/.empty/directory</rootProject.empty.directory>
        <!--
            The absolute path to an empty Failsafe summary file.
         -->
        <rootProject.empty.failsafe.summaryFile>${rootProject.directory}/.empty/failsafe-summary.xml</rootProject.empty.failsafe.summaryFile>

        <!-- Maven version required for the build -->
        <!--
             WARNING: Do not forget to call 'mvn wrapper:wrapper'
             when you update this property!
         -->
        <maven.min.version>3.9.14</maven.min.version>

        <!-- Set this through a property so that it can be overridden from the commandline -->
        <maven.compiler.failOnWarning>true</maven.compiler.failOnWarning>

        <maven.compiler.release>${java-version.main.release}</maven.compiler.release>
        <maven.compiler.testRelease>${java-version.test.release}</maven.compiler.testRelease>

        <!-- Also set source/target, because several other plugins rely on this and don't understand release -->
        <maven.compiler.source>${maven.compiler.release}</maven.compiler.source>
        <maven.compiler.target>${maven.compiler.release}</maven.compiler.target>
        <maven.compiler.testSource>${maven.compiler.testRelease}</maven.compiler.testSource>
        <maven.compiler.testTarget>${maven.compiler.testRelease}</maven.compiler.testTarget>

        <!-- Plugin versions -->
        <version.clean.plugin>3.5.0</version.clean.plugin>
        <version.install.plugin>3.1.4</version.install.plugin>
        <version.enforcer.plugin>3.6.2</version.enforcer.plugin>
        <version.project-info.plugin>3.9.0</version.project-info.plugin>
        <version.japicmp.plugin>0.25.4</version.japicmp.plugin>
        <version.deploy.plugin>3.1.4</version.deploy.plugin>
        <version.flatten-maven-plugin>1.7.3</version.flatten-maven-plugin>
        <version.assembly.plugin>3.8.0</version.assembly.plugin>
        <version.buildhelper.plugin>3.6.1</version.buildhelper.plugin>
        <version.checkstyle.plugin>3.6.0</version.checkstyle.plugin>
        <version.bundle.plugin>6.0.2</version.bundle.plugin>
        <version.compiler.plugin>3.15.0</version.compiler.plugin>
        <version.dependency.plugin>3.10.0</version.dependency.plugin>
        <!-- Check dependencies for security vulnerabilities -->
        <version.dependency-check.plugin>12.2.0</version.dependency-check.plugin>
        <version.exec.plugin>3.6.3</version.exec.plugin>
        <version.forbiddenapis.plugin>3.10</version.forbiddenapis.plugin>
        <!-- Make sure that upgraded Jandex plugin aligns with the Jandex version imported from the ORM platform pom -->
        <version.jandex.plugin>3.5.3</version.jandex.plugin>
        <version.maven.injection.plugin>1.0.2</version.maven.injection.plugin>
        <version.jar.plugin>3.5.0</version.jar.plugin>
        <version.javadoc.plugin>3.12.0</version.javadoc.plugin>
        <version.jdeps.plugin>0.5.1</version.jdeps.plugin>
        <version.processor.plugin>5.1</version.processor.plugin>
        <version.resources.plugin>3.5.0</version.resources.plugin>
        <version.shade.plugin>3.6.2</version.shade.plugin>
        <version.source.plugin>3.4.0</version.source.plugin>
        <!-- Surefire versions are a minefield of bugs: be careful with upgrades -->
        <version.surefire.plugin>3.5.5</version.surefire.plugin>
        <version.surefire.plugin.java-version.asm>9.9.1</version.surefire.plugin.java-version.asm>
        <version.jacoco.plugin>0.8.14</version.jacoco.plugin>
        <version.com.buschmais.jqassistant.plugin>2.9.1</version.com.buschmais.jqassistant.plugin>
        <version.moditect.plugin>1.3.0.Final</version.moditect.plugin>
        <version.sonar.plugin>5.5.0.6356</version.sonar.plugin>
        <version.scripting.plugin>3.1.0</version.scripting.plugin>
        <!--
            We want to keep patch updates for groovy enabled as those may contain compatibility with a more recent JDK versions.
            e.g. 4.0.13 won't work with JDK 23, while 4.0.26 is working just fine.
         -->
        <version.org.apache.groovy.groovy-jsr223>5.0.4</version.org.apache.groovy.groovy-jsr223>
        <version.com.puppycrawl.tools.checkstyle>13.3.0</version.com.puppycrawl.tools.checkstyle>
        <version.versions.plugin>2.21.0</version.versions.plugin>
        <version.maven-wrapper-plugin>3.3.4</version.maven-wrapper-plugin>
        <version.org.eclipse.m2e.lifecycle-mapping>1.0.0</version.org.eclipse.m2e.lifecycle-mapping>
        <version.sisu-maven-plugin>1.0.0</version.sisu-maven-plugin>
        <version.gitflow-incremental-builder>4.5.6</version.gitflow-incremental-builder>
        <version.spotless-maven-plugin>3.3.0</version.spotless-maven-plugin>
        <version.maven-antrun-plugin>3.2.0</version.maven-antrun-plugin>

        <!-- Repository Deployment URLs -->

        <!-- We always publish to a local directory, JReleaser is supposed to take care of publishing to Nexus: -->
        <local.staging.releases.repo.id>staging-deploy</local.staging.releases.repo.id>
        <local.staging.releases.repo.url>file:${maven.multiModuleProjectDirectory}/target/staging-deploy/maven</local.staging.releases.repo.url>
        <central.releases.repo.id>central-releases</central.releases.repo.id>
        <central.releases.repo.url>https://central.sonatype.com/api/v1/publisher/</central.releases.repo.url>
        <central.snapshots.repo.id>central-snapshots</central.snapshots.repo.id>
        <central.snapshots.repo.url>https://central.sonatype.com/repository/maven-snapshots/</central.snapshots.repo.url>

        <!--
            We don't want to publish or sign any modules by default.
            Specific modules will override the setting at their own level.
        -->
        <deploy.skip>true</deploy.skip>

        <!-- Can be overridden by subprojects if dependency convergence cannot be achieved -->
        <enforcer.dependencyconvergence.skip>false</enforcer.dependencyconvergence.skip>

        <!-- Maven Central repository -->

        <mavencentral.repo.url>https://repo.maven.apache.org/maven2/</mavencentral.repo.url>

        <!-- Eclipse repository (for the ECJ compiler, disabled by default) -->

        <eclipse.repo.id>eclipse-staging</eclipse.repo.id>
        <eclipse.repo.url>https://repo.eclipse.org/content/repositories/eclipse-staging/</eclipse.repo.url>
        <!--
                Options to compile with the Eclipse compiler when building with maven (not with the IDE).
                See profile "compiler-eclipse".
                Note the version of ECJ is overridden because the one bundled with the latest plexus-compiler version
                is outdated and leads to compilation errors.
         -->
        <version.org.codehaus.plexus.plexus-compiler.compiler-eclipse>2.14.2</version.org.codehaus.plexus.plexus-compiler.compiler-eclipse>
        <version.org.eclipse.jdt.ecj>3.44.0</version.org.eclipse.jdt.ecj>

        <!-- Asciidoctor -->

        <version.asciidoctor.plugin>3.2.0</version.asciidoctor.plugin>
        <version.org.hibernate.infra.hibernate-asciidoctor-theme>6.1.2.Final</version.org.hibernate.infra.hibernate-asciidoctor-theme>
        <version.org.hibernate.infra.hibernate-asciidoctor-extensions>3.2.0.Final</version.org.hibernate.infra.hibernate-asciidoctor-extensions>
        <version.org.asciidoctor.asciidoctorj>3.0.1</version.org.asciidoctor.asciidoctorj>
        <version.org.asciidoctor.asciidoctorj-pdf>2.3.23</version.org.asciidoctor.asciidoctorj-pdf>

        <!--
            Defines what to do with dependency management section of the flattened pom.
            We'd like to keep the section for the BOMs (since it is the BOM's only purpose).
            But in case of other published modules, we only need the dependencies themselves and not the management section.
            By default, we want to preserve the section and property references to be replaced with values.
        -->
        <flatten-maven-plugin.dependencyManagement.action>resolve</flatten-maven-plugin.dependencyManagement.action>

        <!-- Overridden in profiles to disable the plugin (which doesn't have a 'skip' property...) -->
        <injection-plugin.phase>compile</injection-plugin.phase>

        <javadoc.generate.jar.phase>none</javadoc.generate.jar.phase>
        <javadoc.generate.html.directory>${project.reporting.outputDirectory}/javadocs</javadoc.generate.html.directory>

        <logging.processor.skip.generated.annotation.compiler.argument></logging.processor.skip.generated.annotation.compiler.argument>
        <logging.processor.categories.report.module-name.compiler.argument></logging.processor.categories.report.module-name.compiler.argument>

        <!-- Test settings -->

        <!--
            This is an explicit setting to control compiler plugin execution for the no `-parameters` flag case.
            Needed as when `testIncludes` doesn't match any test classes, it brings all test sources and re-compiles them.
         -->
        <maven.compiler.testSources.noParameterCompilation.skip>true</maven.compiler.testSources.noParameterCompilation.skip>

        <!-- Container images for various integration tests -->
        <!-- The latest version of Elasticsearch tested against by default -->
        <version.org.elasticsearch.latest>9.3.1</version.org.elasticsearch.latest>
        <test.elasticsearch.version></test.elasticsearch.version>
        <test.elasticsearch.distribution>elastic</test.elasticsearch.distribution>

        <!-- Docker images to be pulled. To be redefined in specific profiles of Elasticsearch/OpenSearch \
             or database specific ones. -->
        <test.database.run.kind>h2</test.database.run.kind>

        <test.elasticsearch.run.image.pull>true</test.elasticsearch.run.image.pull>

        <!-- Set empty default values to avoid Maven leaving property references (${...}) when it doesn't find a value -->

        <surefire.jvm.args.memory>-Xmx512m -Xms128m</surefire.jvm.args.memory>
        <surefire.jvm.args.misc>-Djdk.attach.allowAttachSelf=false</surefire.jvm.args.misc>
        <!-- JVM args to be customized depending on the Java version -->
        <surefire.jvm.args.java-version></surefire.jvm.args.java-version>
        <!-- JVM args generated by JaCoCo -->
        <surefire.jvm.args.jacoco></surefire.jvm.args.jacoco>
        <failsafe.jvm.args.jacoco></failsafe.jvm.args.jacoco>

        <!-- JVM args to be customized by each Maven module -->
        <surefire.jvm.args.module></surefire.jvm.args.module>
        <surefire.jvm.args.module.add-opens></surefire.jvm.args.module.add-opens>
        <!--
             Pass these properties as system properties to be able to switch to
             a different database without re-compiling the hibernate.properties file
             (which is located in a dependency of the integration tests modules)
         -->
        <failsafe.jvm.args.hibernate-orm></failsafe.jvm.args.hibernate-orm>
        <!-- Database profile jdbc java arguments -->
        <failsafe.jvm.args.jdbc></failsafe.jvm.args.jdbc>
        <!-- Argument passed from the command line -->
        <test.launcher.args></test.launcher.args>
        <!--
            Caution, jacoco properties use @{...} for late property evaluation:
            http://maven.apache.org/surefire/maven-surefire-plugin/faq.html#late-property-evaluation
            This is necessary for Jacoco to work as expected.
         -->
        <surefire.jvm.args.no-jacoco>${surefire.jvm.args.memory} ${surefire.jvm.args.misc} ${surefire.jvm.args.java-version} ${surefire.jvm.args.module} ${test.launcher.args}</surefire.jvm.args.no-jacoco>
        <failsafe.jvm.args.no-jacoco>${surefire.jvm.args.memory} ${surefire.jvm.args.misc} ${surefire.jvm.args.java-version} ${surefire.jvm.args.module} ${test.launcher.args} ${failsafe.jvm.args.hibernate-orm} ${failsafe.jvm.args.jdbc}</failsafe.jvm.args.no-jacoco>
        <surefire.jvm.args>${surefire.jvm.args.no-jacoco} @{surefire.jvm.args.jacoco}</surefire.jvm.args>
        <failsafe.jvm.args>${surefire.jvm.args.no-jacoco} @{failsafe.jvm.args.jacoco}</failsafe.jvm.args>

        <jacoco.environment.sub-directory>${surefire.environment}</jacoco.environment.sub-directory>

        <!-- Disable integration tests selectively. To be set in specific profile, e.g. for a specific JDK version. -->
        <failsafe.spring.skip>false</failsafe.spring.skip>

        <!-- This allows us to distinguish between multiple executions of the same test in test reports. -->
        <surefire.executionIdentifier>${surefire.module}-${surefire.environment}</surefire.executionIdentifier>
        <!-- This should be set from the command line by CI jobs that execute the same tests in multiple environments -->
        <surefire.environment>default</surefire.environment>
        <!-- This should be set in modules that re-execute tests imported from a dependency (using <dependenciesToScan>)
             to differentiate multiple executions of the same tests in multiple modules. -->
        <surefire.module>default</surefire.module>

        <!-- Formatting -->
        <format.skip>false</format.skip>
        <goal.spotless-maven-plugin>apply</goal.spotless-maven-plugin>

        <!-- For Reproducible Builds -->
        <project.build.outputTimestamp>2026-02-05T22:20:57Z</project.build.outputTimestamp>

        <!-- Sonar options -->
        <!--
            We want to take into account coverage data from integration tests from other projects as well.
            This requires to use a single destination file for ITs, because:
             - Integration tests cover code from other modules.
             - The Sonar plugin computes coverage when inspecting each module,
               and by default only takes into account JaCoCo coverage reports from the inspected module.
               Thus it ignores some relevant ITs by default.
             - Even when configured, the Sonar plugin only accept an *explicit* list of JaCoCo coverage reports
               (no wildcards).
               Thus we cannot easily configure the Sonar plugin to inspect JaCoCo coverage reports from other modules,
               unless we somehow aggregate all of the coverage data into a single, shared JaCoCo coverage report.
            The chosen solution was to make the "reports" module invoke jacoco's "report-aggregate" goal
            to create a single aggregate report, and configure sonar to only inspect that file.

            Useful resources to understand what is going on (caution, not everything is up-to-date):
             - https://docs.sonarqube.org/display/SONAR/Analysis+Parameters
             - https://docs.sonarqube.org/display/PLUG/Usage+of+JaCoCo+with+Java+Plugin
             - https://www.devcon5.ch/en/blog/2015/05/29/multi-module-integration-test-coverage-sonar-jacoco/
             - http://javamemento.blogspot.fr/2016/02/sonar-jacoco-maven-multi-module.html
             - https://github.com/SonarSource/sonar-scanning-examples/blob/master/sonarqube-scanner-maven/pom.xml
             - https://stackoverflow.com/a/49528226/6692043
             - https://www.eclemma.org/jacoco/trunk/doc/report-aggregate-mojo.html
             - Not relevant anymore, but we used to merge *.exec files: https://www.eclemma.org/jacoco/trunk/doc/merge-mojo.html
         -->
        <sonar.coverage.jacoco.xmlReportPaths>${rootProject.directory}/build/reports/target/site/jacoco-aggregate/jacoco.xml</sonar.coverage.jacoco.xmlReportPaths>
        <!--
            Exclude build code and integration tests defined in the main source (utils, Showcases, Backend TCK)
            from coverage computation.
         -->
        <sonar.coverage.exclusions>
            **/org/hibernate/checkstyle/**,
            **/org/hibernate/search/build/enforcer/**,
            **/org/hibernate/search/util/impl/test/**,
            **/org/hibernate/search/util/impl/integrationtest/**,
            **/org/hibernate/search/integrationtest/**
        </sonar.coverage.exclusions>
        <!--
            Exclude build code, unit tests and integration tests from duplication analysis.
         -->
        <sonar.cpd.exclusions>
            **/org/hibernate/checkstyle/**,
            **/org/hibernate/search/build/enforcer/**,
            **/src/test/java/**,
            **/org/hibernate/search/integrationtest/**,
            **/lucene-next/**
        </sonar.cpd.exclusions>
    </properties>

    <build>
        <defaultGoal>install</defaultGoal>
        <resources>
            <resource>
                <!-- The default resource dir: -->
                <directory>${project.basedir}/src/main/resources</directory>
            </resource>
        </resources>
        <pluginManagement>
            <plugins>
                <!--
                    Clean and install plugins will be called from the root,
                    so we want to make sure that their versions are aligned
                 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>${version.clean.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>${version.install.plugin}</version>
                </plugin>
                <!--
                    We want to do some custom enforcer rules on the public BOM,
                 `  hence we manage enforcer version in the root pom.
                 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-enforcer-plugin</artifactId>
                    <version>${version.enforcer.plugin}</version>
                    <executions>
                        <execution>
                            <id>enforce-common-rules</id>
                            <goals>
                                <goal>enforce</goal>
                            </goals>
                            <configuration>
                                <rules>
                                    <requireJavaVersion>
                                        <version>[${jdk.min.version},)</version>
                                    </requireJavaVersion>
                                    <requireMavenVersion>
                                        <version>${maven.min.version}</version>
                                    </requireMavenVersion>
                                    <banDuplicatePomDependencyVersions />
                                </rules>
                            </configuration>
                        </execution>
                        <execution>
                            <id>enforce-dependency-convergence</id>
                            <goals>
                                <goal>enforce</goal>
                            </goals>
                            <configuration>
                                <skip>${enforcer.dependencyconvergence.skip}</skip>
                                <rules>
                                    <DependencyConvergence />
                                </rules>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <!-- We want to deploy the public BOM, so we manage this plugin in the root pom. -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>${version.deploy.plugin}</version>
                    <configuration>
                        <skip>${deploy.skip}</skip>
                    </configuration>
                </plugin>
                <!-- Public BOM will be flattened too, so we manage this plugin in the root pom. -->
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>flatten-maven-plugin</artifactId>
                    <version>${version.flatten-maven-plugin}</version>
                    <configuration>
                        <outputDirectory>${project.build.directory}</outputDirectory>
                        <!-- Keep things like url, inceptionYear, authors...
                             everything that's required by the OSSRH Maven repository -->
                        <flattenMode>ossrh</flattenMode>
                    </configuration>
                    <executions>
                        <execution>
                            <id>flatten-pom</id>
                            <phase>process-resources</phase>
                            <goals>
                                <goal>flatten</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-wrapper-plugin</artifactId>
                    <version>${version.maven-wrapper-plugin}</version>
                    <configuration>
                        <mavenVersion>${maven.min.version}</mavenVersion>
                        <distributionType>bin</distributionType>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>com.github.marschall</groupId>
                    <artifactId>jdeps-maven-plugin</artifactId>
                    <version>${version.jdeps.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>${version.resources.plugin}</version>
                    <configuration>
                        <!-- Don't overwrite existing files if the destination files are newer.
                             Necessary to avoid rebuilding JARs when executing Maven twice,
                             which has dramatic cascading effects as it leads to recompiling
                             sources for all depending projects. -->
                        <overwrite>false</overwrite>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>${version.jar.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>${version.compiler.plugin}</version>
                    <configuration>
                        <fork>true</fork>
                        <showWarnings>true</showWarnings>
                        <showDeprecation>true</showDeprecation>
                        <failOnWarning>${maven.compiler.failOnWarning}</failOnWarning>
                        <release>${maven.compiler.release}</release>
                        <testRelease>${maven.compiler.testRelease}</testRelease>
                        <encoding>UTF-8</encoding>
                        <compilerArgs>
                            <compilerArg>-Xlint:unchecked</compilerArg>
                            <compilerArg>${logging.processor.skip.generated.annotation.compiler.argument}</compilerArg>
                            <compilerArg>${logging.processor.categories.report.module-name.compiler.argument}</compilerArg>
                        </compilerArgs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>default-compile</id>
                            <configuration>
                                <executable>${java-version.main.compiler}</executable>
                            </configuration>
                        </execution>
                        <execution>
                            <id>default-testCompile</id>
                            <configuration>
                                <proc>none</proc>
                                <executable>${java-version.test.compiler}</executable>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.bsc.maven</groupId>
                    <artifactId>maven-processor-plugin</artifactId>
                    <version>${version.processor.plugin}</version>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>${version.assembly.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-javadoc-plugin</artifactId>
                    <version>${version.javadoc.plugin}</version>
                    <configuration>
                        <outputDirectory>${javadoc.generate.html.directory}</outputDirectory>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>${version.source.plugin}</version>
                    <executions>
                        <execution>
                            <id>attach-sources</id>
                            <phase>verify</phase>
                            <goals>
                                <goal>jar-no-fork</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>${version.dependency.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>${version.exec.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.felix</groupId>
                    <artifactId>maven-bundle-plugin</artifactId>
                    <extensions>true</extensions>
                    <version>${version.bundle.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>${version.shade.plugin}</version>
                    <configuration>
                        <createDependencyReducedPom>false</createDependencyReducedPom>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>build-helper-maven-plugin</artifactId>
                    <version>${version.buildhelper.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>versions-maven-plugin</artifactId>
                    <version>${version.versions.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>de.thetaphi</groupId>
                    <artifactId>forbiddenapis</artifactId>
                    <version>${version.forbiddenapis.plugin}</version>
                    <configuration>
                        <!-- if the used Java version is too new, don't fail, just do nothing: -->
                        <failOnUnsupportedJava>false</failOnUnsupportedJava>
                        <failOnMissingClasses>false</failOnMissingClasses>
                        <ignoreSignaturesOfMissingClasses>true</ignoreSignaturesOfMissingClasses>
                        <suppressAnnotations>
                            <suppressAnnotation>javax.annotation.processing.Generated</suppressAnnotation>
                            <suppressAnnotation>org.hibernate.search.util.common.annotation.impl.SuppressForbiddenApis</suppressAnnotation>
                            <suppressAnnotation>org.hibernate.search.util.impl.test.annotation.SuppressForbiddenApis</suppressAnnotation>
                        </suppressAnnotations>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-checkstyle-plugin</artifactId>
                    <version>${version.checkstyle.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.moditect</groupId>
                    <artifactId>moditect-maven-plugin</artifactId>
                    <version>${version.moditect.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.jboss.maven.plugins</groupId>
                    <artifactId>maven-injection-plugin</artifactId>
                    <version>${version.maven.injection.plugin}</version>
                    <executions>
                        <execution>
                            <phase>${injection-plugin.phase}</phase>
                            <goals>
                                <goal>bytecode</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>io.smallrye</groupId>
                    <artifactId>jandex-maven-plugin</artifactId>
                    <version>${version.jandex.plugin}</version>
                    <executions>
                        <execution>
                            <id>make-index</id>
                            <goals>
                                <goal>jandex</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>

                <!--
                    Test configuration
                 -->

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>${version.surefire.plugin}</version>
                    <configuration>
                        <forkCount>1</forkCount>
                        <reuseForks>true</reuseForks>
                        <redirectTestOutputToFile>true</redirectTestOutputToFile>
                        <runOrder>alphabetical</runOrder>
                        <!--
                             Stack traces for failing tests are useless if trimStackTrace = true (the default).
                             See https://issues.apache.org/jira/browse/SUREFIRE-1226?focusedCommentId=16187391&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-16187391
                         -->
                        <trimStackTrace>false</trimStackTrace>
                        <jvm>${java-version.test.launcher}</jvm>
                        <argLine>${surefire.jvm.args}</argLine>
                        <!--
                            Better test names in test reports.
                            See https://maven.apache.org/surefire/maven-surefire-plugin/examples/junit-platform.html#Surefire_Extensions_and_Reports_Configuration_for_.40DisplayName
                            Don't ask me why this isn't the default
                        -->
                        <statelessTestsetReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5Xml30StatelessReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                            <usePhrasedTestSuiteClassName>true</usePhrasedTestSuiteClassName>
                            <usePhrasedTestCaseClassName>true</usePhrasedTestCaseClassName>
                            <usePhrasedTestCaseMethodName>true</usePhrasedTestCaseMethodName>
                        </statelessTestsetReporter>
                        <consoleOutputReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5ConsoleOutputReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                        </consoleOutputReporter>
                        <statelessTestsetInfoReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5StatelessTestsetInfoReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                            <usePhrasedClassNameInRunning>true</usePhrasedClassNameInRunning>
                            <usePhrasedClassNameInTestCaseSummary>true</usePhrasedClassNameInTestCaseSummary>
                        </statelessTestsetInfoReporter>
                        <reportNameSuffix>${surefire.executionIdentifier}</reportNameSuffix>
                    </configuration>
                    <dependencies>
                        <!--
                             maven-surefire-plugin and maven-failsafe-plugin use an older version of ASM
                             that cannot handle Java 15+ bytecode.
                             Let's upgrade that dependency and hope for the best;
                             if it doesn't work, the build is very likely to fail and we'll know about it.
                         -->
                        <dependency>
                            <groupId>org.ow2.asm</groupId>
                            <artifactId>asm</artifactId>
                            <version>${version.surefire.plugin.java-version.asm}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <version>${version.surefire.plugin}</version>
                    <configuration>
                        <forkCount>1</forkCount>
                        <reuseForks>true</reuseForks>
                        <redirectTestOutputToFile>true</redirectTestOutputToFile>
                        <runOrder>alphabetical</runOrder>
                        <!--
                             Stack traces for failing tests are useless if trimStackTrace = true (the default).
                             See https://issues.apache.org/jira/browse/SUREFIRE-1226?focusedCommentId=16187391&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-16187391
                         -->
                        <trimStackTrace>false</trimStackTrace>
                        <jvm>${java-version.test.launcher}</jvm>
                        <argLine>${failsafe.jvm.args}</argLine>
                        <!-- Catch configuration problems that could cause the plugin
                             to not detect any tests.
                             For example, in the past, we've had:
                             - JUnit 5 Jupiter creeping up our classpath through transitive dependencies,
                               causing the maven-failsafe-plugin to simply switch to JUnit 5 mode and
                               ignore all JUnit 4 tests.
                             - Misconfigured "source copy" artifacts (e.g. jakarta) that ended up not copying tests
                               from the original module at all.
                         -->
                        <failIfNoTests>true</failIfNoTests>
                        <!--
                            Better test names in test reports.
                            See https://maven.apache.org/surefire/maven-surefire-plugin/examples/junit-platform.html#Surefire_Extensions_and_Reports_Configuration_for_.40DisplayName
                            Don't ask me why this isn't the default
                        -->
                        <statelessTestsetReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5Xml30StatelessReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                            <usePhrasedTestSuiteClassName>true</usePhrasedTestSuiteClassName>
                            <usePhrasedTestCaseClassName>true</usePhrasedTestCaseClassName>
                            <usePhrasedTestCaseMethodName>true</usePhrasedTestCaseMethodName>
                        </statelessTestsetReporter>
                        <consoleOutputReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5ConsoleOutputReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                        </consoleOutputReporter>
                        <statelessTestsetInfoReporter implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5StatelessTestsetInfoReporter">
                            <usePhrasedFileName>true</usePhrasedFileName>
                            <usePhrasedClassNameInRunning>true</usePhrasedClassNameInRunning>
                            <usePhrasedClassNameInTestCaseSummary>true</usePhrasedClassNameInTestCaseSummary>
                        </statelessTestsetInfoReporter>
                        <reportNameSuffix>${surefire.executionIdentifier}</reportNameSuffix>
                    </configuration>
                    <dependencies>
                        <!--
                             maven-surefire-plugin and maven-failsafe-plugin use an older version of ASM
                             that cannot handle Java 15+ bytecode.
                             Let's upgrade that dependency and hope for the best;
                             if it doesn't work, the build is very likely to fail and we'll know about it.
                         -->
                        <dependency>
                            <groupId>org.ow2.asm</groupId>
                            <artifactId>asm</artifactId>
                            <version>${version.surefire.plugin.java-version.asm}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.jacoco</groupId>
                    <artifactId>jacoco-maven-plugin</artifactId>
                    <version>${version.jacoco.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.asciidoctor</groupId>
                    <artifactId>asciidoctor-maven-plugin</artifactId>
                    <version>${version.asciidoctor.plugin}</version>
                    <configuration>
                        <!-- Enabled to validate internal links -->
                        <enableVerbose>true</enableVerbose>
                        <!-- Abort the build if something seems wrong -->
                        <logHandler>
                            <failIf>
                                <severity>WARN</severity>
                            </failIf>
                        </logHandler>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>org.asciidoctor</groupId>
                            <artifactId>asciidoctorj</artifactId>
                            <version>${version.org.asciidoctor.asciidoctorj}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.asciidoctor</groupId>
                            <artifactId>asciidoctorj-pdf</artifactId>
                            <version>${version.org.asciidoctor.asciidoctorj-pdf}</version>
                        </dependency>
                        <dependency>
                            <groupId>org.hibernate.infra</groupId>
                            <artifactId>hibernate-asciidoctor-extensions</artifactId>
                            <version>${version.org.hibernate.infra.hibernate-asciidoctor-extensions}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.sonarsource.scanner.maven</groupId>
                    <artifactId>sonar-maven-plugin</artifactId>
                    <version>${version.sonar.plugin}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-scripting-plugin</artifactId>
                    <version>${version.scripting.plugin}</version>
                    <executions>
                        <execution>
                            <id>list-container-images</id>
                            <configuration>
                                <engineName>groovy</engineName>
                                <!--
                                     Note that expressions ('${...}') are evaluated by Maven before the script is
                                     interpreted by the Groovy interpreter.
                                     That's the only way to access profile-defined properties,
                                     since accessing project.properties within the script will ignore profiles.
                                 -->
                                <script><![CDATA[
                                    def images = []
                                    def isTrueString = { string -> string && Boolean.parseBoolean( string ) }
                                    def isNotBlankString = { string -> string?.trim() }
                                    def parseImage = { file ->
                                        {
                                            def dockerFileContent = new File(file).text
                                            if ((match = dockerFileContent =~ /FROM (.+)/)) {
                                                return match.group(1).trim()
                                            }
                                            return ''
                                        }
                                    }

                                    images += parseImage( './build/container/ryuk.Dockerfile' )
                                    if ( isNotBlankString( '${test.database.run.kind}' ) && '${test.database.run.kind}' != 'h2') {
                                        images += parseImage( './build/container/database/${test.database.run.kind}.Dockerfile' )
                                    }
                                    if ( isTrueString( '${test.elasticsearch.run.image.pull}' ) ) {
                                        def fromFile = parseImage( './build/container/search-backend/${test.elasticsearch.distribution}.Dockerfile')
                                        def suppliedVersion = '${test.elasticsearch.version}'
                                        if (isNotBlankString(suppliedVersion)) {
                                            def matcher = fromFile =~ /FROM ([^@:\s]+)(?::([^@\s]+))?(@.+)?/
                                            if (matcher.find()) {
                                                def name = matcher.group(1)
                                                def maybeTag = matcher.group(2)
                                                def maybeHash = matcher.group(3)

                                                if (suppliedVersion == maybeTag) {
                                                    images += fromFile
                                                } else {
                                                    images += name + ":" + suppliedVersion
                                                }
                                            } else {
                                                images += fromFile
                                            }
                                        } else {
                                            images += fromFile
                                        }
                                    }
                                    // Exclude images from non-dockerhub repositories
                                    new File('${containerImagesListFile}').append( images.join('\n') + '\n' )
                                ]]></script>
                            </configuration>
                        </execution>
                    </executions>
                    <dependencies>
                        <!-- ScriptEngines -->
                        <dependency>
                            <groupId>org.apache.groovy</groupId>
                            <artifactId>groovy-jsr223</artifactId>
                            <version>${version.org.apache.groovy.groovy-jsr223}</version> <!-- look for latest -->
                        </dependency>
                    </dependencies>
                </plugin>
                <!--
                    Code formatting configuration:
                -->
                <plugin>
                    <groupId>com.diffplug.spotless</groupId>
                    <artifactId>spotless-maven-plugin</artifactId>
                    <version>${version.spotless-maven-plugin}</version>
                    <configuration>
                        <upToDateChecking>
                            <enabled>true</enabled>
                            <indexFile>${project.basedir}/.cache/spotless-index-${version.spotless-maven-plugin}</indexFile>
                        </upToDateChecking>
                        <formats>
                            <format>
                                <!-- XML specific rules -->
                                <includes>
                                    <include>src/**/*.xml</include>
                                </includes>
                                <trimTrailingWhitespace/>
                                <endWithNewline/>
                                <licenseHeader>
                                    <file>license.xml.header</file>
                                    <!-- Delimiter is a regex which identifies the "top" of the file i.e. all above it is considered a header -->
                                    <delimiter><![CDATA[(\n)*^(<[^!?]+|<!DOCTYPE.+)$]]></delimiter>
                                    <skipLinesMatching><![CDATA[<\?xml.+\?>]]></skipLinesMatching>
                                </licenseHeader>
                                <indent>
                                    <tabs>true</tabs>
                                    <spacesPerTab>4</spacesPerTab>
                                </indent>
                            </format>
                            <format>
                                <!-- Asciidoctor specific rules -->
                                <includes>
                                    <include>**/*.adoc</include>
                                </includes>
                                <trimTrailingWhitespace/>
                                <endWithNewline/>
                                <licenseHeader>
                                    <file>license.adoc.header</file>
                                    <delimiter>(\n)*^((?!\/\/ .+).+)$</delimiter>
                                </licenseHeader>
                            </format>
                            <format>
                                <!-- Property files specific rules -->
                                <includes>
                                    <include>**/src/**/*.properties</include>
                                </includes>
                                <trimTrailingWhitespace/>
                                <endWithNewline/>
                                <licenseHeader>
                                    <file>license.properties.header</file>
                                    <delimiter><![CDATA[^\n?(?!# SPDX-License-Identifier: Apache-2.0)(?!# Copyright Red Hat Inc. and Hibernate Authors).+]]></delimiter>
                                </licenseHeader>
                            </format>
                        </formats>
                        <!-- define a language-specific format -->
                        <java>
                            <toggleOffOn/>
                            <includes>
                                <include>src/**/*.java</include>
                            </includes>
                            <excludes>
                                <!-- Ignore avro-generated classes as we have them commited to the repository: -->
                                <exclude>**/main/avro/generated/**/*.java</exclude>
                            </excludes>
                            <indent>
                                <tabs>true</tabs>
                                <spacesPerTab>4</spacesPerTab>
                            </indent>

                            <importOrder>
                                <file>hibernate_search_style.importorder</file>
                            </importOrder>
                            <trimTrailingWhitespace/>
                            <endWithNewline/>
                            <eclipse>
                                <!-- optional version of Eclipse Formatter -->
                                <!-- <version>4.26</version> -->
                                <file>hibernate_search_style.xml</file>
                            </eclipse>
                            <removeUnusedImports>
                                <!-- default one fails to process the classes -->
                                <engine>cleanthat-javaparser-unnecessaryimport</engine>
                            </removeUnusedImports>
                            <licenseHeader>
                                <file>license.java.header</file>
                                <!-- Delimiter is a regex which identifies the "top" of the file i.e. all above it is considered a header -->
                                <delimiter>(\n)*^(\/\/tag.+|\/\/spotless.+|package .+;|\/\/.+$|(?!package .+;)import .+;|/\*\*.*)</delimiter>
                            </licenseHeader>
                            <replaceRegex>
                                <name>Remove wildcard imports</name>
                                <searchRegex>^import\s+[^\*\s]+\*;$</searchRegex>
                                <replacement>$1</replacement>
                            </replaceRegex>
                        </java>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>org.hibernate.search</groupId>
                            <artifactId>hibernate-search-build-config</artifactId>
                            <version>${project.version}</version>
                        </dependency>
                    </dependencies>
                    <executions>
                        <execution>
                            <id>check-apply-formatting</id>
                            <configuration>
                                <skip>${format.skip}</skip>
                            </configuration>
                            <phase>process-sources</phase>
                            <goals>
                                <goal>${goal.spotless-maven-plugin}</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.eclipse.sisu</groupId>
                    <artifactId>sisu-maven-plugin</artifactId>
                    <version>${version.sisu-maven-plugin}</version>
                </plugin>
                <plugin>
                    <groupId>io.github.gitflow-incremental-builder</groupId>
                    <artifactId>gitflow-incremental-builder</artifactId>
                    <version>${version.gitflow-incremental-builder}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-antrun-plugin</artifactId>
                    <version>${version.maven-antrun-plugin}</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <executions>
                    <execution>
                        <!--
                            Copy LICENSE.txt to META-INF in the build output directory.
                            Previously done via a project-level <resource> pointing at ${rootProject.directory},
                            but that caused the entire workspace root to be fingerprinted as a build cache input
                            for all goals consuming project resources (e.g. checkstyle:check), breaking
                            build cache relocatability.
                        -->
                        <id>copy-license</id>
                        <phase>generate-resources</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.outputDirectory}/META-INF</outputDirectory>
                            <resources>
                                <resource>
                                    <directory>${rootProject.directory}</directory>
                                    <includes>
                                        <include>LICENSE.txt</include>
                                    </includes>
                                </resource>
                            </resources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>com.github.marschall</groupId>
                <artifactId>jdeps-maven-plugin</artifactId>
                <!--
                    Not enabling automatic executions; run:
                     > mvn jdeps:jdeps
                     to get a report.
                -->
                <configuration>
                    <!-- Allows to see which JRE profiles will be needed -->
                    <profile>true</profile>
                    <failOnWarning>true</failOnWarning>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>set-root-location-property</id>
                        <goals>
                            <goal>rootlocation</goal>
                        </goals>
                        <configuration>
                            <rootLocationProperty>rootProject.directory</rootLocationProperty>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-project-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate.search</propertyPrefix>
                            <versionString>${project.version}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>parse-project-previous-stable-version</id>
                        <goals>
                            <goal>parse-version</goal>
                        </goals>
                        <configuration>
                            <propertyPrefix>parsed-version.org.hibernate.search.previous-stable</propertyPrefix>
                            <versionString>${version.org.hibernate.search.previous-stable}</versionString>
                        </configuration>
                    </execution>
                    <execution>
                        <id>add-test-source-noparameters</id>
                        <goals>
                            <goal>add-test-source</goal>
                        </goals>
                        <configuration>
                            <sources>
                                <source>src/test/java-noparameters</source>
                            </sources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <distributionManagement>
        <repository>
            <id>${central.releases.repo.id}</id>
            <name>Maven Central Releases Repository</name>
            <url>${central.releases.repo.url}</url>
        </repository>
        <snapshotRepository>
            <id>${central.snapshots.repo.id}</id>
            <name>Maven Central Snapshots Repository</name>
            <url>${central.snapshots.repo.url}</url>
        </snapshotRepository>
    </distributionManagement>

    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>${version.project-info.plugin}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>index</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>com.github.siom79.japicmp</groupId>
                <artifactId>japicmp-maven-plugin</artifactId>
                <version>${version.japicmp.plugin}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>cmp-report</report>
                        </reports>
                    </reportSet>
                </reportSets>
                <configuration>
                    <skip>true</skip>
                    <oldVersion>
                        <dependency>
                            <groupId>org.hibernate.search</groupId>
                            <artifactId>${project.artifactId}</artifactId>
                            <version>${version.org.hibernate.search.previous-stable}</version>
                            <type>${project.packaging}</type>
                        </dependency>
                    </oldVersion>
                    <newVersion>
                        <file>
                            <path>
                                ${project.build.directory}/${project.artifactId}-${project.version}.${project.packaging}
                            </path>
                        </file>
                    </newVersion>
                    <parameter>
                        <onlyModified>true</onlyModified>
                        <excludes>
                            <exclude>org.hibernate.search.*.impl</exclude>
                        </excludes>
                        <accessModifier>public</accessModifier>
                        <!--
                            The next two should make sure that this report is not run for this POM-packaged parent module itself
                            That's not working, though, resulting a build failure. I'm thus setting skip to "true" below, which
                            needs to be overridden within those modules for which this report should be created
                        -->
                        <skipPomModules>true</skipPomModules>
                        <packagingSupporteds>
                            <packagingSupported>jar</packagingSupported>
                        </packagingSupporteds>
                    </parameter>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </reporting>

    <profiles>
        <profile>
            <id>dist</id>
            <modules>
                <module>distribution</module>
                <module>build/configuration-properties-collector</module>
            </modules>
        </profile>

        <profile>
            <id>release</id>
            <activation>
                <property>
                    <name>performRelease</name>
                    <value>true</value>
                </property>
            </activation>
            <properties>
                <!-- We want this execution to happen before moditect (which executes at package phase) -->
                <javadoc.generate.jar.phase>prepare-package</javadoc.generate.jar.phase>
            </properties>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <artifactId>maven-deploy-plugin</artifactId>
                            <configuration>
                                <altReleaseDeploymentRepository>${local.staging.releases.repo.id}::${local.staging.releases.repo.url}</altReleaseDeploymentRepository>
                            </configuration>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
        </profile>

        <profile>
            <id>skip-checks</id>
            <properties>
                <enforcer.skip>true</enforcer.skip>
                <checkstyle.skip>true</checkstyle.skip>
                <format.skip>true</format.skip>
                <forbiddenapis.skip>true</forbiddenapis.skip>
            </properties>
        </profile>

        <profile>
            <id>testWithJdkSpecifiedExplicitly</id>
            <activation>
                <property>
                    <name>java-version.test.compiler.java_home</name>
                </property>
            </activation>
            <properties>
                <!-- ForbiddenAPIs uses the Maven JDK to resolve signatures,
                     which leads to some trouble when using a different JDK version to compile tests
                     (see https://hibernate.atlassian.net/browse/HSEARCH-4521)
                     Since the main build is supposed to catch all forbidden API invocations already,
                     we can safely disable ForbiddenAPIs in builds that target other JDKs. -->
                <forbiddenapis.skip>true</forbiddenapis.skip>
            </properties>
        </profile>

        <profile>
            <id>testWithJdk26</id>
            <activation>
                <property>
                    <name>java-version.test.release</name>
                    <value>26</value>
                </property>
            </activation>
            <properties>
                <!-- Spring Boot 3 isn't ready for JDK26 yet -->
                <failsafe.spring.skip>true</failsafe.spring.skip>
            </properties>
        </profile>

        <profile>
            <id>compiler-eclipse</id>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <artifactId>maven-compiler-plugin</artifactId>
                            <configuration>
                                <compilerId>eclipse</compilerId>
                                <!-- ECJ doesn't seem to understand the "release" argument -->
                                <release></release>
                                <source>${maven.compiler.release}</source>
                                <target>${maven.compiler.release}</target>
                                <compilerArgs>
                                    <!-- Ignore warnings in generated code -->
                                    <compilerArg>-nowarn:[${project.build.directory}/generated-sources/apt]</compilerArg>
                                    <!-- For a list of warning categories that can be passed to -warn,
                                         see https://git.eclipse.org/c/jdt/eclipse.jdt.core.git/tree/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties#n376
                                     -->
                                    <!-- Ignore warnings that we don't care about -->
                                    <compilerArg>-warn:-serial,intfAnnotation</compilerArg>
                                    <!-- Ignore warnings that give false positives with ecj (or are addressed by other tools) -->
                                    <compilerArg>-warn:-unusedImport,warningToken,unusedPrivate,enumSwitch</compilerArg>
                                </compilerArgs>
                            </configuration>
                            <executions>
                                <execution>
                                    <id>default-testCompile</id>
                                    <configuration>
                                        <compilerArgs combine.children="append">
                                            <!-- Ignore warnings that are too annoying for tests -->
                                            <compilerArg>-warn:-unused,resource</compilerArg>
                                        </compilerArgs>
                                    </configuration>
                                </execution>
                                <execution>
                                    <id>noparameters-testCompile</id>
                                    <configuration>
                                        <compilerArgs combine.children="append">
                                            <!-- Ignore warnings that are too annoying for tests -->
                                            <compilerArg>-warn:-unused,resource</compilerArg>
                                        </compilerArgs>
                                    </configuration>
                                </execution>
                            </executions>
                            <dependencies>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-api</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-manager</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.codehaus.plexus</groupId>
                                    <artifactId>plexus-compiler-eclipse</artifactId>
                                    <version>${version.org.codehaus.plexus.plexus-compiler.compiler-eclipse}</version>
                                </dependency>
                                <dependency>
                                    <groupId>org.eclipse.jdt</groupId>
                                    <artifactId>ecj</artifactId>
                                    <version>${version.org.eclipse.jdt.ecj}</version>
                                </dependency>
                            </dependencies>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
            <pluginRepositories>
                <!--
                     This is needed to access pre-release versions of ECJ,
                     when bugs that affect us are fixed but not yet released.
                     It's been used in particular to get a fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=547807.
                     This configuration *MUST STAY IN A SPECIFIC PROFILE*,
                     otherwise it would "taint" projects that depend on Hibernate Search.
                 -->
                <pluginRepository>
                    <id>${eclipse.repo.id}</id>
                    <url>${eclipse.repo.url}</url>
                    <releases>
                        <enabled>true</enabled>
                        <updatePolicy>never</updatePolicy>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </pluginRepository>
            </pluginRepositories>
        </profile>

        <profile>
            <id>coverage</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.jacoco</groupId>
                        <artifactId>jacoco-maven-plugin</artifactId>
                        <configuration>
                            <excludes>
                                <exclude>**/*_$logger.class</exclude>
                                <exclude>**/*_$bundle.class</exclude>
                                <!-- Exclude DTOs generated by Avro -->
                                <exclude>org/hibernate/search/mapper/orm/coordination/outboxpolling/avro/generated/impl/**</exclude>
                            </excludes>
                        </configuration>
                        <executions>
                            <execution>
                                <id>jacoco-prepare-agent</id>
                                <goals>
                                    <goal>prepare-agent</goal>
                                </goals>
                                <configuration>
                                    <propertyName>surefire.jvm.args.jacoco</propertyName>
                                </configuration>
                            </execution>
                            <execution>
                                <id>jacoco-prepare-agent-integration</id>
                                <!--
                                    This is necessary in order for the property to be set before we process resources,
                                    such as arquillian.xml in WildFly tests or maven.properties in OSGi tests.
                                 -->
                                <phase>initialize</phase>
                                <goals>
                                    <goal>prepare-agent-integration</goal>
                                </goals>
                                <configuration>
                                    <propertyName>failsafe.jvm.args.jacoco</propertyName>
                                    <destFile>${project.build.directory}/${jacoco.environment.sub-directory}/jacoco.exec</destFile>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <!--
           A profile executing jqassistant scanning and analysis for all relevant modules.
           Our rules are in build/jqassistant/rules.xml.
           See CONTRIBUTING.md for usage.
       -->
        <profile>
            <id>jqassistant</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.buschmais.jqassistant</groupId>
                        <artifactId>jqassistant-maven-plugin</artifactId>
                        <version>${version.com.buschmais.jqassistant.plugin}</version>
                        <configuration>
                            <configurationLocations>
                                <!-- Any JQAssistant configurations go in this yml file:  -->
                                <configurationLocation>build/jqassistant/.jqassistant.yml</configurationLocation>
                            </configurationLocations>
                        </configuration>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>scan</goal>
                                    <goal>analyze</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>owasp</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.owasp</groupId>
                        <artifactId>dependency-check-maven</artifactId>
                        <version>${version.dependency-check.plugin}</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>aggregate</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>ci-build</id>
            <properties>
                <goal.spotless-maven-plugin>check</goal.spotless-maven-plugin>
            </properties>
        </profile>

        <profile>
            <id>IDEA</id>
            <!--
            Dependencies to allow easy project import in IntelliJ IDEA.
            These should not be listed as project dependencies to users
            but are necessary during compile time as they include the
            JBoss Logger annotation processor.
            -->
            <activation>
                <!-- This is a trick to have the profile automatically activated by IDEA -->
                <property>
                    <name>idea.maven.embedder.version</name>
                </property>
            </activation>
            <properties>
                <!-- Intellij IDEA only understands the main -release argument,
                     so we need to do this in order for tests to compile.
                     Here's the issue in the IDEA bug tracker: https://youtrack.jetbrains.com/issue/IDEA-85478
                     It's fixed in 2022.1 EAP 6, so hopefully we'll be able to get rid of this soon. -->
                <java-version.main.release>${java-version.test.release}</java-version.main.release>
                <!-- Dependency convergence checks seem to fail in IntelliJ IDEA,
                     for some reason. Maybe it's because of the two additional dependencies below.
                     Anyway, let's disable these checks so the build works correctly in IDEA. -->
                <enforcer.dependencyconvergence.skip>true</enforcer.dependencyconvergence.skip>
            </properties>
            <!-- See build parent POM for any additional IDEA-specific configurations. -->
        </profile>

        <profile>
            <id>eclipse</id>
            <activation>
                <property>
                    <!-- This is a trick to have the profile automatically activated by Eclipse -->
                    <name>m2e.version</name>
                </property>
            </activation>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <!--
                                This plugin's configuration is used in m2e only.
                                We want to configure this in a separate profile because the plugin doesn't really exist
                                and Maven will complain because it doesn't find it if executed outside of Eclipse.
                             -->
                            <groupId>org.eclipse.m2e</groupId>
                            <artifactId>lifecycle-mapping</artifactId>
                            <version>${version.org.eclipse.m2e.lifecycle-mapping}</version>
                            <configuration>
                                <lifecycleMappingMetadata>
                                    <pluginExecutions>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.apache.maven.plugins</groupId>
                                                <artifactId>maven-dependency-plugin</artifactId>
                                                <versionRange>[2.1,)</versionRange>
                                                <goals>
                                                    <goal>unpack</goal>
                                                    <goal>unpack-dependencies</goal>
                                                    <goal>build-classpath</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.apache.felix</groupId>
                                                <artifactId>maven-bundle-plugin</artifactId>
                                                <versionRange>[2.3.7,)</versionRange>
                                                <goals>
                                                    <goal>manifest</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>org.codehaus.mojo</groupId>
                                                <artifactId>build-helper-maven-plugin</artifactId>
                                                <versionRange>[1.9.1,)</versionRange>
                                                <goals>
                                                    <goal>parse-version</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>de.thetaphi</groupId>
                                                <artifactId>forbiddenapis</artifactId>
                                                <versionRange>[3.1,)</versionRange>
                                                <goals>
                                                    <goal>check</goal>
                                                    <goal>testCheck</goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore />
                                            </action>
                                        </pluginExecution>
                                        <pluginExecution>
                                            <pluginExecutionFilter>
                                                <groupId>
                                                    org.asciidoctor
                                                </groupId>
                                                <artifactId>
                                                    asciidoctor-maven-plugin
                                                </artifactId>
                                                <versionRange>
                                                    [2.2.1,)
                                                </versionRange>
                                                <goals>
                                                    <goal>
                                                        process-asciidoc
                                                    </goal>
                                                </goals>
                                            </pluginExecutionFilter>
                                            <action>
                                                <ignore></ignore>
                                            </action>
                                        </pluginExecution>
                                    </pluginExecutions>
                                </lifecycleMappingMetadata>
                            </configuration>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
        </profile>

        <profile>
            <id>incremental</id>
            <activation>
                <property>
                    <name>incremental</name>
                </property>
            </activation>
            <properties>
                <!-- The *local* main, not refs/remotes/... -->
                <!-- This property is overridden in CI jobs to point to refs/remotes/...
                        so that CI build can find the sources to compare to. -->
                <gib.referenceBranch>main</gib.referenceBranch>
                <gib.disableSelectedProjectsHandling>true</gib.disableSelectedProjectsHandling>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>io.github.gitflow-incremental-builder</groupId>
                        <artifactId>gitflow-incremental-builder</artifactId>
                        <extensions>true</extensions>
                        <!-- https://github.com/gitflow-incremental-builder/gitflow-incremental-builder#configuration
                             General recap: Anything that is directly set in <configuration> cannot be redefined via '-D...'!
                             See also: https://github.com/gitflow-incremental-builder/gitflow-incremental-builder/issues/213 -->
                        <configuration>
                            <!-- pointless to attempt incremental build if something like mvnw was changed -->
                            <skipIfPathMatches>\.mvn[/\\].*|mvnw.*</skipIfPathMatches>
                            <!--
                                Let's ignore any changes in the files that do not affect documentation, classes, build resources
                                e.g. various readme or text files.

                                Use [/\\] for path separators because of Windows.
                            -->
                            <excludePathsMatching>[/\\][^/\\]*\.(md|txt)|[/\\]\..*|[/\\].*[/\\]README\.(md|txt)|[/\\]ci[/\\]dependency-update[/\\].*</excludePathsMatching>
                            <!-- The reports module always needs to be built, otherwise we don't generate
                                 some important reports like coverage reports -->
                            <forceBuildModules>hibernate-search-reports</forceBuildModules>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <!--
                This profile set some properties to make running repro build easier.
                Instead of
                    mvn clean package -Pskip-checks -DskipTests -Dmaven.javadoc.skip -Dgpg.skip \
                        -Dno-build-cache -Dbuildinfo.detect.skip=false \
                        -Dbuildinfo.skipModules='**/**internal**,**/**integrationtest**,**/**parent**,**/**documentation**,**/**reports**,**/**build**'
                We can run
                    mvn clean package -Pskip-checks -Preproducibility-check -Dno-build-cache
            -->
            <id>reproducibility-check</id>
            <properties>
                <maven.javadoc.skip>true</maven.javadoc.skip>
                <skipTests>true</skipTests>
            </properties>
        </profile>

        <!--
             WARNING: this MUST be the very last profile,
             so that the "report" module is the very last module,
             in particular when deploying artifacts to a Nexus repository.
             See the "build/reports" module POM for more information.
         -->
        <profile>
            <id>build-reports-as-last-module</id>
            <activation>
                <property>
                    <name>!some.property.that.will.never.exist</name>
                </property>
            </activation>
            <modules>
                <module>build/reports</module>
            </modules>
        </profile>

        <!-- DO NOT ADD ANY PROFILE AFTER THIS: see above -->
    </profiles>
</project>